(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@polkadot/util'), require('@polkadot/util-crypto')) :
    typeof define === 'function' && define.amd ? define(['exports', '@polkadot/util', '@polkadot/util-crypto'], factory) :
    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.polkadotTypes = {}, global.polkadotUtil, global.polkadotUtilCrypto));
})(this, (function (exports, util, utilCrypto) { 'use strict';

    const global = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : window;

    var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
    const AllHashers = {
        Blake2_128: null,
        Blake2_256: null,
        Blake2_128Concat: null,
        Twox128: null,
        Twox256: null,
        Twox64Concat: null,
        Identity: null
    };

    const META_V1_TO_V2 = {
        metadata: {
            description: 'Returns the metadata of a runtime',
            params: [],
            type: 'OpaqueMetadata'
        }
    };
    const runtime$t = {
        Metadata: [
            {
                methods: {
                    metadata_at_version: {
                        description: 'Returns the metadata at a given version.',
                        params: [
                            {
                                name: 'version',
                                type: 'u32'
                            }
                        ],
                        type: 'Option<OpaqueMetadata>'
                    },
                    metadata_versions: {
                        description: 'Returns the supported metadata versions.',
                        params: [],
                        type: 'Vec<u32>'
                    },
                    ...META_V1_TO_V2
                },
                version: 2
            },
            {
                methods: {
                    ...META_V1_TO_V2
                },
                version: 1
            }
        ]
    };

    const v9 = {
        ErrorMetadataV9: {
            name: 'Text',
            docs: 'Vec<Text>'
        },
        EventMetadataV9: {
            name: 'Text',
            args: 'Vec<Type>',
            docs: 'Vec<Text>'
        },
        FunctionArgumentMetadataV9: {
            name: 'Text',
            type: 'Type'
        },
        FunctionMetadataV9: {
            name: 'Text',
            args: 'Vec<FunctionArgumentMetadataV9>',
            docs: 'Vec<Text>'
        },
        MetadataV9: {
            modules: 'Vec<ModuleMetadataV9>'
        },
        ModuleConstantMetadataV9: {
            name: 'Text',
            type: 'Type',
            value: 'Bytes',
            docs: 'Vec<Text>'
        },
        ModuleMetadataV9: {
            name: 'Text',
            storage: 'Option<StorageMetadataV9>',
            calls: 'Option<Vec<FunctionMetadataV9>>',
            events: 'Option<Vec<EventMetadataV9>>',
            constants: 'Vec<ModuleConstantMetadataV9>',
            errors: 'Vec<ErrorMetadataV9>'
        },
        StorageEntryMetadataV9: {
            name: 'Text',
            modifier: 'StorageEntryModifierV9',
            type: 'StorageEntryTypeV9',
            fallback: 'Bytes',
            docs: 'Vec<Text>'
        },
        StorageEntryModifierV9: {
            _enum: ['Optional', 'Default', 'Required']
        },
        StorageEntryTypeV9: {
            _enum: {
                Plain: 'Type',
                Map: {
                    hasher: 'StorageHasherV9',
                    key: 'Type',
                    value: 'Type',
                    linked: 'bool'
                },
                DoubleMap: {
                    hasher: 'StorageHasherV9',
                    key1: 'Type',
                    key2: 'Type',
                    value: 'Type',
                    key2Hasher: 'StorageHasherV9'
                }
            }
        },
        StorageHasherV9: {
            _enum: {
                Blake2_128: null,
                Blake2_256: null,
                Twox128: null,
                Twox256: null,
                Twox64Concat: null
            }
        },
        StorageMetadataV9: {
            prefix: 'Text',
            items: 'Vec<StorageEntryMetadataV9>'
        }
    };

    const v10 = {
        ErrorMetadataV10: 'ErrorMetadataV9',
        EventMetadataV10: 'EventMetadataV9',
        FunctionArgumentMetadataV10: 'FunctionArgumentMetadataV9',
        FunctionMetadataV10: 'FunctionMetadataV9',
        MetadataV10: {
            modules: 'Vec<ModuleMetadataV10>'
        },
        ModuleConstantMetadataV10: 'ModuleConstantMetadataV9',
        ModuleMetadataV10: {
            name: 'Text',
            storage: 'Option<StorageMetadataV10>',
            calls: 'Option<Vec<FunctionMetadataV10>>',
            events: 'Option<Vec<EventMetadataV10>>',
            constants: 'Vec<ModuleConstantMetadataV10>',
            errors: 'Vec<ErrorMetadataV10>'
        },
        StorageEntryModifierV10: 'StorageEntryModifierV9',
        StorageEntryMetadataV10: {
            name: 'Text',
            modifier: 'StorageEntryModifierV10',
            type: 'StorageEntryTypeV10',
            fallback: 'Bytes',
            docs: 'Vec<Text>'
        },
        StorageEntryTypeV10: {
            _enum: {
                Plain: 'Type',
                Map: {
                    hasher: 'StorageHasherV10',
                    key: 'Type',
                    value: 'Type',
                    linked: 'bool'
                },
                DoubleMap: {
                    hasher: 'StorageHasherV10',
                    key1: 'Type',
                    key2: 'Type',
                    value: 'Type',
                    key2Hasher: 'StorageHasherV10'
                }
            }
        },
        StorageMetadataV10: {
            prefix: 'Text',
            items: 'Vec<StorageEntryMetadataV10>'
        },
        StorageHasherV10: {
            _enum: {
                Blake2_128: null,
                Blake2_256: null,
                Blake2_128Concat: null,
                Twox128: null,
                Twox256: null,
                Twox64Concat: null
            }
        }
    };

    const v11 = {
        ErrorMetadataV11: 'ErrorMetadataV10',
        EventMetadataV11: 'EventMetadataV10',
        ExtrinsicMetadataV11: {
            version: 'u8',
            signedExtensions: 'Vec<Text>'
        },
        FunctionArgumentMetadataV11: 'FunctionArgumentMetadataV10',
        FunctionMetadataV11: 'FunctionMetadataV10',
        MetadataV11: {
            modules: 'Vec<ModuleMetadataV11>',
            extrinsic: 'ExtrinsicMetadataV11'
        },
        ModuleConstantMetadataV11: 'ModuleConstantMetadataV10',
        ModuleMetadataV11: {
            name: 'Text',
            storage: 'Option<StorageMetadataV11>',
            calls: 'Option<Vec<FunctionMetadataV11>>',
            events: 'Option<Vec<EventMetadataV11>>',
            constants: 'Vec<ModuleConstantMetadataV11>',
            errors: 'Vec<ErrorMetadataV11>'
        },
        StorageEntryModifierV11: 'StorageEntryModifierV10',
        StorageEntryMetadataV11: {
            name: 'Text',
            modifier: 'StorageEntryModifierV11',
            type: 'StorageEntryTypeV11',
            fallback: 'Bytes',
            docs: 'Vec<Text>'
        },
        StorageEntryTypeV11: {
            _enum: {
                Plain: 'Type',
                Map: {
                    hasher: 'StorageHasherV11',
                    key: 'Type',
                    value: 'Type',
                    linked: 'bool'
                },
                DoubleMap: {
                    hasher: 'StorageHasherV11',
                    key1: 'Type',
                    key2: 'Type',
                    value: 'Type',
                    key2Hasher: 'StorageHasherV11'
                }
            }
        },
        StorageMetadataV11: {
            prefix: 'Text',
            items: 'Vec<StorageEntryMetadataV11>'
        },
        StorageHasherV11: {
            _enum: AllHashers
        }
    };

    const v12 = {
        ErrorMetadataV12: 'ErrorMetadataV11',
        EventMetadataV12: 'EventMetadataV11',
        ExtrinsicMetadataV12: 'ExtrinsicMetadataV11',
        FunctionArgumentMetadataV12: 'FunctionArgumentMetadataV11',
        FunctionMetadataV12: 'FunctionMetadataV11',
        MetadataV12: {
            modules: 'Vec<ModuleMetadataV12>',
            extrinsic: 'ExtrinsicMetadataV12'
        },
        ModuleConstantMetadataV12: 'ModuleConstantMetadataV11',
        ModuleMetadataV12: {
            name: 'Text',
            storage: 'Option<StorageMetadataV12>',
            calls: 'Option<Vec<FunctionMetadataV12>>',
            events: 'Option<Vec<EventMetadataV12>>',
            constants: 'Vec<ModuleConstantMetadataV12>',
            errors: 'Vec<ErrorMetadataV12>',
            index: 'u8'
        },
        StorageEntryModifierV12: 'StorageEntryModifierV11',
        StorageEntryMetadataV12: 'StorageEntryMetadataV11',
        StorageEntryTypeV12: 'StorageEntryTypeV11',
        StorageMetadataV12: 'StorageMetadataV11',
        StorageHasherV12: 'StorageHasherV11'
    };

    const v13 = {
        ErrorMetadataV13: 'ErrorMetadataV12',
        EventMetadataV13: 'EventMetadataV12',
        ExtrinsicMetadataV13: 'ExtrinsicMetadataV12',
        FunctionArgumentMetadataV13: 'FunctionArgumentMetadataV12',
        FunctionMetadataV13: 'FunctionMetadataV12',
        MetadataV13: {
            modules: 'Vec<ModuleMetadataV13>',
            extrinsic: 'ExtrinsicMetadataV13'
        },
        ModuleConstantMetadataV13: 'ModuleConstantMetadataV12',
        ModuleMetadataV13: {
            name: 'Text',
            storage: 'Option<StorageMetadataV13>',
            calls: 'Option<Vec<FunctionMetadataV13>>',
            events: 'Option<Vec<EventMetadataV13>>',
            constants: 'Vec<ModuleConstantMetadataV13>',
            errors: 'Vec<ErrorMetadataV13>',
            index: 'u8'
        },
        StorageEntryModifierV13: 'StorageEntryModifierV12',
        StorageEntryMetadataV13: {
            name: 'Text',
            modifier: 'StorageEntryModifierV13',
            type: 'StorageEntryTypeV13',
            fallback: 'Bytes',
            docs: 'Vec<Text>'
        },
        StorageEntryTypeV13: {
            _enum: {
                Plain: 'Type',
                Map: {
                    hasher: 'StorageHasherV13',
                    key: 'Type',
                    value: 'Type',
                    linked: 'bool'
                },
                DoubleMap: {
                    hasher: 'StorageHasherV13',
                    key1: 'Type',
                    key2: 'Type',
                    value: 'Type',
                    key2Hasher: 'StorageHasherV13'
                },
                NMap: {
                    keyVec: 'Vec<Type>',
                    hashers: 'Vec<StorageHasherV13>',
                    value: 'Type'
                }
            }
        },
        StorageMetadataV13: {
            prefix: 'Text',
            items: 'Vec<StorageEntryMetadataV13>'
        },
        StorageHasherV13: 'StorageHasherV12'
    };

    const Si1Variant = {
        name: 'Text',
        fields: 'Vec<Si1Field>',
        index: 'u8',
        docs: 'Vec<Text>'
    };
    const v1$1 = {
        Si1Field: {
            name: 'Option<Text>',
            type: 'Si1LookupTypeId',
            typeName: 'Option<Text>',
            docs: 'Vec<Text>'
        },
        Si1LookupTypeId: 'Compact<u32>',
        Si1Path: 'Si0Path',
        Si1Type: {
            path: 'Si1Path',
            params: 'Vec<Si1TypeParameter>',
            def: 'Si1TypeDef',
            docs: 'Vec<Text>'
        },
        Si1TypeDef: {
            _enum: {
                Composite: 'Si1TypeDefComposite',
                Variant: 'Si1TypeDefVariant',
                Sequence: 'Si1TypeDefSequence',
                Array: 'Si1TypeDefArray',
                Tuple: 'Si1TypeDefTuple',
                Primitive: 'Si1TypeDefPrimitive',
                Compact: 'Si1TypeDefCompact',
                BitSequence: 'Si1TypeDefBitSequence',
                HistoricMetaCompat: 'Type'
            }
        },
        Si1TypeDefArray: {
            len: 'u32',
            type: 'Si1LookupTypeId'
        },
        Si1TypeDefBitSequence: {
            bitStoreType: 'Si1LookupTypeId',
            bitOrderType: 'Si1LookupTypeId'
        },
        Si1TypeDefCompact: {
            type: 'Si1LookupTypeId'
        },
        Si1TypeDefComposite: {
            fields: 'Vec<Si1Field>'
        },
        Si1TypeDefPrimitive: 'Si0TypeDefPrimitive',
        Si1TypeDefSequence: {
            type: 'Si1LookupTypeId'
        },
        Si1TypeDefTuple: 'Vec<Si1LookupTypeId>',
        Si1TypeParameter: {
            name: 'Text',
            type: 'Option<Si1LookupTypeId>'
        },
        Si1TypeDefVariant: {
            variants: 'Vec<Si1Variant>'
        },
        Si1Variant
    };

    const v14 = {
        PortableTypeV14: {
            id: 'Si1LookupTypeId',
            type: 'Si1Type'
        },
        ErrorMetadataV14: {
            ...Si1Variant,
            args: 'Vec<Type>'
        },
        EventMetadataV14: {
            ...Si1Variant,
            args: 'Vec<Type>'
        },
        FunctionArgumentMetadataV14: {
            name: 'Text',
            type: 'Type',
            typeName: 'Option<Type>'
        },
        FunctionMetadataV14: {
            ...Si1Variant,
            args: 'Vec<FunctionArgumentMetadataV14>'
        },
        ExtrinsicMetadataV14: {
            type: 'SiLookupTypeId',
            version: 'u8',
            signedExtensions: 'Vec<SignedExtensionMetadataV14>'
        },
        MetadataV14: {
            lookup: 'PortableRegistry',
            pallets: 'Vec<PalletMetadataV14>',
            extrinsic: 'ExtrinsicMetadataV14',
            type: 'SiLookupTypeId'
        },
        PalletCallMetadataV14: {
            type: 'SiLookupTypeId'
        },
        PalletConstantMetadataV14: {
            name: 'Text',
            type: 'SiLookupTypeId',
            value: 'Bytes',
            docs: 'Vec<Text>'
        },
        PalletErrorMetadataV14: {
            type: 'SiLookupTypeId'
        },
        PalletEventMetadataV14: {
            type: 'SiLookupTypeId'
        },
        PalletMetadataV14: {
            name: 'Text',
            storage: 'Option<PalletStorageMetadataV14>',
            calls: 'Option<PalletCallMetadataV14>',
            events: 'Option<PalletEventMetadataV14>',
            constants: 'Vec<PalletConstantMetadataV14>',
            errors: 'Option<PalletErrorMetadataV14>',
            index: 'u8'
        },
        PalletStorageMetadataV14: {
            prefix: 'Text',
            items: 'Vec<StorageEntryMetadataV14>'
        },
        SignedExtensionMetadataV14: {
            identifier: 'Text',
            type: 'SiLookupTypeId',
            additionalSigned: 'SiLookupTypeId'
        },
        StorageEntryMetadataV14: {
            name: 'Text',
            modifier: 'StorageEntryModifierV14',
            type: 'StorageEntryTypeV14',
            fallback: 'Bytes',
            docs: 'Vec<Text>'
        },
        StorageEntryModifierV14: 'StorageEntryModifierV13',
        StorageEntryTypeV14: {
            _enum: {
                Plain: 'SiLookupTypeId',
                Map: {
                    hashers: 'Vec<StorageHasherV14>',
                    key: 'SiLookupTypeId',
                    value: 'SiLookupTypeId'
                }
            }
        },
        StorageHasherV14: 'StorageHasherV13'
    };

    const v15 = {
        CustomMetadata15: {
            map: 'BTreeMap<Text, CustomValueMetadata15>'
        },
        CustomValueMetadata15: {
            type: 'SiLookupTypeId',
            value: 'Bytes'
        },
        ExtrinsicMetadataV15: {
            version: 'u8',
            addressType: 'SiLookupTypeId',
            callType: 'SiLookupTypeId',
            signatureType: 'SiLookupTypeId',
            extraType: 'SiLookupTypeId',
            signedExtensions: 'Vec<SignedExtensionMetadataV14>'
        },
        OuterEnums15: {
            callType: 'SiLookupTypeId',
            eventType: 'SiLookupTypeId',
            errorType: 'SiLookupTypeId'
        },
        PalletMetadataV15: {
            name: 'Text',
            storage: 'Option<PalletStorageMetadataV14>',
            calls: 'Option<PalletCallMetadataV14>',
            events: 'Option<PalletEventMetadataV14>',
            constants: 'Vec<PalletConstantMetadataV14>',
            errors: 'Option<PalletErrorMetadataV14>',
            index: 'u8',
            docs: 'Vec<Text>'
        },
        RuntimeApiMetadataV15: {
            name: 'Text',
            methods: 'Vec<RuntimeApiMethodMetadataV15>',
            docs: 'Vec<Text>'
        },
        RuntimeApiMethodMetadataV15: {
            name: 'Text',
            inputs: 'Vec<RuntimeApiMethodParamMetadataV15>',
            output: 'SiLookupTypeId',
            docs: 'Vec<Text>'
        },
        RuntimeApiMethodParamMetadataV15: {
            name: 'Text',
            type: 'SiLookupTypeId'
        },
        MetadataV15: {
            lookup: 'PortableRegistry',
            pallets: 'Vec<PalletMetadataV15>',
            extrinsic: 'ExtrinsicMetadataV15',
            type: 'SiLookupTypeId',
            apis: 'Vec<RuntimeApiMetadataV15>',
            outerEnums: 'OuterEnums15',
            custom: 'CustomMetadata15'
        }
    };

    const definitions$17 = {
        rpc: {},
        runtime: runtime$t,
        types: {
            ...v9,
            ...v10,
            ...v11,
            ...v12,
            ...v13,
            ...v14,
            ...v15,
            ErrorMetadataLatest: 'ErrorMetadataV14',
            EventMetadataLatest: 'EventMetadataV14',
            ExtrinsicMetadataLatest: 'ExtrinsicMetadataV15',
            FunctionArgumentMetadataLatest: 'FunctionArgumentMetadataV14',
            FunctionMetadataLatest: 'FunctionMetadataV14',
            MetadataLatest: 'MetadataV15',
            PalletCallMetadataLatest: 'PalletCallMetadataV14',
            PalletConstantMetadataLatest: 'PalletConstantMetadataV14',
            PalletErrorMetadataLatest: 'PalletErrorMetadataV14',
            PalletEventMetadataLatest: 'PalletEventMetadataV14',
            PalletMetadataLatest: 'PalletMetadataV15',
            PalletStorageMetadataLatest: 'PalletStorageMetadataV14',
            PortableType: 'PortableTypeV14',
            RuntimeApiMetadataLatest: 'RuntimeApiMetadataV15',
            SignedExtensionMetadataLatest: 'SignedExtensionMetadataV14',
            StorageEntryMetadataLatest: 'StorageEntryMetadataV14',
            StorageEntryModifierLatest: 'StorageEntryModifierV14',
            StorageEntryTypeLatest: 'StorageEntryTypeV14',
            StorageHasher: 'StorageHasherV14',
            OpaqueMetadata: 'Opaque<Bytes>',
            MetadataAll: {
                _enum: {
                    V0: 'DoNotConstruct<MetadataV0>',
                    V1: 'DoNotConstruct<MetadataV1>',
                    V2: 'DoNotConstruct<MetadataV2>',
                    V3: 'DoNotConstruct<MetadataV3>',
                    V4: 'DoNotConstruct<MetadataV4>',
                    V5: 'DoNotConstruct<MetadataV5>',
                    V6: 'DoNotConstruct<MetadataV6>',
                    V7: 'DoNotConstruct<MetadataV7>',
                    V8: 'DoNotConstruct<MetadataV8>',
                    V9: 'MetadataV9',
                    V10: 'MetadataV10',
                    V11: 'MetadataV11',
                    V12: 'MetadataV12',
                    V13: 'MetadataV13',
                    V14: 'MetadataV14',
                    V15: 'MetadataV15'
                }
            }
        }
    };

    const CORE_V1_TO_V4 = {
        execute_block: {
            description: 'Execute the given block.',
            params: [
                {
                    name: 'block',
                    type: 'Block'
                }
            ],
            type: 'Null'
        }
    };
    const CORE_V1_TO_V2 = {
        version: {
            description: 'Returns the version of the runtime.',
            params: [],
            type: 'RuntimeVersionPre3'
        }
    };
    const CORE_V2_TO_V4 = {
        initialize_block: {
            description: 'Initialize a block with the given header.',
            params: [
                {
                    name: 'header',
                    type: 'Header'
                }
            ],
            type: 'Null'
        }
    };
    const runtime$s = {
        Core: [
            {
                methods: {
                    version: {
                        description: 'Returns the version of the runtime.',
                        params: [],
                        type: 'RuntimeVersion'
                    },
                    ...CORE_V1_TO_V4,
                    ...CORE_V2_TO_V4
                },
                version: 4
            },
            {
                methods: {
                    version: {
                        description: 'Returns the version of the runtime.',
                        params: [],
                        type: 'RuntimeVersionPre4'
                    },
                    ...CORE_V1_TO_V4,
                    ...CORE_V2_TO_V4
                },
                version: 3
            },
            {
                methods: {
                    ...CORE_V1_TO_V2,
                    ...CORE_V1_TO_V4,
                    ...CORE_V2_TO_V4
                },
                version: 2
            },
            {
                methods: {
                    initialise_block: {
                        description: 'Initialize a block with the given header.',
                        params: [
                            {
                                name: 'header',
                                type: 'Header'
                            }
                        ],
                        type: 'Null'
                    },
                    ...CORE_V1_TO_V2,
                    ...CORE_V1_TO_V4
                },
                version: 1
            }
        ]
    };

    const numberTypes = {
        Fixed64: 'Int<64, Fixed64>',
        FixedI64: 'Int<64, FixedI64>',
        FixedU64: 'UInt<64, FixedU64>',
        Fixed128: 'Int<128, Fixed128>',
        FixedI128: 'Int<128, FixedI128>',
        FixedU128: 'UInt<128, FixedU128>',
        I32F32: 'Int<64, I32F32>',
        U32F32: 'UInt<64, U32F32>',
        PerU16: 'UInt<16, PerU16>',
        Perbill: 'UInt<32, Perbill>',
        Percent: 'UInt<8, Percent>',
        Permill: 'UInt<32, Permill>',
        Perquintill: 'UInt<64, Perquintill>'
    };
    const knownOrigins = {
        Council: 'CollectiveOrigin',
        System: 'SystemOrigin',
        TechnicalCommittee: 'CollectiveOrigin',
        Xcm: 'XcmOrigin',
        XcmPallet: 'XcmOrigin',
        Authority: 'AuthorityOrigin',
        GeneralCouncil: 'CollectiveOrigin'
    };
    const definitions$16 = {
        rpc: {},
        runtime: runtime$s,
        types: {
            ...numberTypes,
            AccountId: 'AccountId32',
            AccountId20: 'GenericEthereumAccountId',
            AccountId32: 'GenericAccountId32',
            AccountId33: 'GenericAccountId33',
            AccountIdOf: 'AccountId',
            AccountIndex: 'GenericAccountIndex',
            Address: 'MultiAddress',
            AssetId: 'u32',
            Balance: 'UInt<128, Balance>',
            BalanceOf: 'Balance',
            Block: 'GenericBlock',
            BlockNumber: 'u32',
            BlockNumberFor: 'BlockNumber',
            BlockNumberOf: 'BlockNumber',
            Call: 'GenericCall',
            CallHash: 'Hash',
            CallHashOf: 'CallHash',
            ChangesTrieConfiguration: {
                digestInterval: 'u32',
                digestLevels: 'u32'
            },
            ChangesTrieSignal: {
                _enum: {
                    NewConfiguration: 'Option<ChangesTrieConfiguration>'
                }
            },
            ConsensusEngineId: 'GenericConsensusEngineId',
            CodecHash: 'Hash',
            CrateVersion: {
                major: 'u16',
                minor: 'u8',
                patch: 'u8'
            },
            Digest: {
                logs: 'Vec<DigestItem>'
            },
            DigestItem: {
                _enum: {
                    Other: 'Bytes',
                    AuthoritiesChange: 'Vec<AuthorityId>',
                    ChangesTrieRoot: 'Hash',
                    SealV0: 'SealV0',
                    Consensus: 'Consensus',
                    Seal: 'Seal',
                    PreRuntime: 'PreRuntime',
                    ChangesTrieSignal: 'ChangesTrieSignal',
                    RuntimeEnvironmentUpdated: 'Null'
                }
            },
            ExtrinsicsWeight: {
                normal: 'Weight',
                operational: 'Weight'
            },
            H32: '[u8; 4; H32]',
            H64: '[u8; 8; H64]',
            H128: '[u8; 16; H128]',
            H160: '[u8; 20; H160]',
            H256: '[u8; 32; H256]',
            H512: '[u8; 64; H512]',
            H1024: '[u8; 128; H1024]',
            H2048: '[u8; 256; H2048]',
            Hash: 'H256',
            Header: {
                parentHash: 'Hash',
                number: 'Compact<BlockNumber>',
                stateRoot: 'Hash',
                extrinsicsRoot: 'Hash',
                digest: 'Digest'
            },
            HeaderPartial: {
                parentHash: 'Hash',
                number: 'BlockNumber'
            },
            IndicesLookupSource: 'GenericLookupSource',
            Index: 'u32',
            Justification: '(ConsensusEngineId, EncodedJustification)',
            EncodedJustification: 'Bytes',
            Justifications: 'Vec<Justification>',
            KeyValue: '(StorageKey, StorageData)',
            KeyTypeId: 'u32',
            LockIdentifier: '[u8; 8]',
            LookupSource: 'MultiAddress',
            LookupTarget: 'AccountId',
            ModuleId: 'LockIdentifier',
            MultiAddress: 'GenericMultiAddress',
            MultiSigner: {
                _enum: {
                    Ed25519: '[u8; 32]',
                    Sr25519: '[u8; 32]',
                    Ecdsa: '[u8; 33]'
                }
            },
            Moment: 'UInt<64, Moment>',
            OpaqueCall: 'Bytes',
            Origin: 'DoNotConstruct<Origin>',
            OriginCaller: {
                _enum: {
                    System: 'SystemOrigin'
                }
            },
            PalletId: 'LockIdentifier',
            PalletsOrigin: 'OriginCaller',
            PalletVersion: {
                major: 'u16',
                minor: 'u8',
                patch: 'u8'
            },
            Pays: {
                _enum: ['Yes', 'No']
            },
            Phantom: 'Null',
            PhantomData: 'Null',
            Releases: {
                _enum: ['V1', 'V2', 'V3', 'V4', 'V5', 'V6', 'V7', 'V8', 'V9', 'V10']
            },
            RuntimeCall: 'Call',
            RuntimeEvent: 'Event',
            RuntimeDbWeight: {
                read: 'Weight',
                write: 'Weight'
            },
            SignedBlock: 'SignedBlockWithJustifications',
            SignedBlockWithJustification: {
                block: 'Block',
                justification: 'Option<EncodedJustification>'
            },
            SignedBlockWithJustifications: {
                block: 'Block',
                justifications: 'Option<Justifications>'
            },
            Slot: 'u64',
            SlotDuration: 'u64',
            StorageData: 'Bytes',
            StorageInfo: {
                palletName: 'Bytes',
                storage_name: 'Bytes',
                prefix: 'Bytes',
                maxValues: 'Option<u32>',
                maxSize: 'Option<u32>'
            },
            StorageProof: {
                trieNodes: 'Vec<Bytes>'
            },
            TransactionPriority: 'u64',
            TransactionLongevity: 'u64',
            TransactionTag: 'Bytes',
            TransactionInfo: {
                _alias: {
                    dataSize: 'size'
                },
                chunkRoot: 'H256',
                contentHash: 'H256',
                dataSize: 'u32',
                blockChunks: 'u32'
            },
            TransactionStorageProof: {
                chunk: 'Vec<u8>',
                proof: 'Vec<Vec<u8>>'
            },
            ValidatorId: 'AccountId',
            ValidatorIdOf: 'ValidatorId',
            WeightV0: 'u32',
            WeightV1: 'u64',
            WeightV2: {
                refTime: 'Compact<u64>',
                proofSize: 'Compact<u64>'
            },
            Weight: 'WeightV2',
            WeightMultiplier: 'Fixed64',
            PreRuntime: '(ConsensusEngineId, Bytes)',
            SealV0: '(u64, Signature)',
            Seal: '(ConsensusEngineId, Bytes)',
            Consensus: '(ConsensusEngineId, Bytes)'
        }
    };

    const v0$1 = {
        Si0Field: {
            name: 'Option<Text>',
            type: 'Si0LookupTypeId',
            typeName: 'Option<Text>',
            docs: 'Vec<Text>'
        },
        Si0LookupTypeId: 'u32',
        Si0Path: 'Vec<Text>',
        Si0Type: {
            path: 'Si0Path',
            params: 'Vec<Si0LookupTypeId>',
            def: 'Si0TypeDef'
        },
        Si0TypeDef: {
            _enum: {
                Composite: 'Si0TypeDefComposite',
                Variant: 'Si0TypeDefVariant',
                Sequence: 'Si0TypeDefSequence',
                Array: 'Si0TypeDefArray',
                Tuple: 'Si0TypeDefTuple',
                Primitive: 'Si0TypeDefPrimitive',
                Compact: 'Si0TypeDefCompact',
                Phantom: 'Si0TypeDefPhantom',
                BitSequence: 'Si0TypeDefBitSequence'
            }
        },
        Si0TypeDefArray: {
            len: 'u32',
            type: 'Si0LookupTypeId'
        },
        Si0TypeDefBitSequence: {
            bitStoreType: 'Si0LookupTypeId',
            bitOrderType: 'Si0LookupTypeId'
        },
        Si0TypeDefCompact: {
            type: 'Si0LookupTypeId'
        },
        Si0TypeDefComposite: {
            fields: 'Vec<Si0Field>'
        },
        Si0TypeDefPhantom: 'Null',
        Si0TypeDefVariant: {
            variants: 'Vec<Si0Variant>'
        },
        Si0TypeDefPrimitive: {
            _enum: ['Bool', 'Char', 'Str', 'U8', 'U16', 'U32', 'U64', 'U128', 'U256', 'I8', 'I16', 'I32', 'I64', 'I128', 'I256']
        },
        Si0TypeDefSequence: {
            type: 'Si0LookupTypeId'
        },
        Si0TypeDefTuple: 'Vec<Si0LookupTypeId>',
        Si0TypeParameter: {
            name: 'Text',
            type: 'Option<Si0LookupTypeId>'
        },
        Si0Variant: {
            name: 'Text',
            fields: 'Vec<Si0Field>',
            index: 'Option<u8>',
            discriminant: 'Option<u64>',
            docs: 'Vec<Text>'
        }
    };

    const definitions$15 = {
        rpc: {},
        types: {
            ...v0$1,
            ...v1$1,
            SiField: 'Si1Field',
            SiLookupTypeId: 'Si1LookupTypeId',
            SiPath: 'Si1Path',
            SiType: 'Si1Type',
            SiTypeDef: 'Si1TypeDef',
            SiTypeDefArray: 'Si1TypeDefArray',
            SiTypeDefBitSequence: 'Si1TypeDefBitSequence',
            SiTypeDefCompact: 'Si1TypeDefCompact',
            SiTypeDefComposite: 'Si1TypeDefComposite',
            SiTypeDefPrimitive: 'Si1TypeDefPrimitive',
            SiTypeDefSequence: 'Si1TypeDefSequence',
            SiTypeDefTuple: 'Si1TypeDefTuple',
            SiTypeParameter: 'Si1TypeParameter',
            SiTypeDefVariant: 'Si1TypeDefVariant',
            SiVariant: 'Si1Variant'
        }
    };

    const runtime$r = {
        AssetConversionApi: [
            {
                methods: {
                    get_reserves: {
                        description: 'Get pool reserves',
                        params: [
                            {
                                name: 'asset1',
                                type: 'XcmV3MultiLocation'
                            },
                            {
                                name: 'asset2',
                                type: 'XcmV3MultiLocation'
                            }
                        ],
                        type: 'Option<(Balance,Balance)>'
                    },
                    quote_price_exact_tokens_for_tokens: {
                        description: 'Quote price: exact tokens for tokens',
                        params: [
                            {
                                name: 'asset1',
                                type: 'XcmV3MultiLocation'
                            },
                            {
                                name: 'asset2',
                                type: 'XcmV3MultiLocation'
                            },
                            {
                                name: 'amount',
                                type: 'u128'
                            },
                            {
                                name: 'include_fee',
                                type: 'bool'
                            }
                        ],
                        type: 'Option<(Balance)>'
                    },
                    quote_price_tokens_for_exact_tokens: {
                        description: 'Quote price: tokens for exact tokens',
                        params: [
                            {
                                name: 'asset1',
                                type: 'XcmV3MultiLocation'
                            },
                            {
                                name: 'asset2',
                                type: 'XcmV3MultiLocation'
                            },
                            {
                                name: 'amount',
                                type: 'u128'
                            },
                            {
                                name: 'include_fee',
                                type: 'bool'
                            }
                        ],
                        type: 'Option<(Balance)>'
                    }
                },
                version: 1
            }
        ]
    };

    const definitions$14 = {
        rpc: {},
        runtime: runtime$r,
        types: {
            TAssetConversion: 'Option<MultiLocation>'
        }
    };

    const runtime$q = {
        AssetsApi: [
            {
                methods: {
                    account_balances: {
                        description: 'Return the current set of authorities.',
                        params: [
                            {
                                name: 'account',
                                type: 'AccountId'
                            }
                        ],
                        type: 'Vec<(u32, TAssetBalance)>'
                    }
                },
                version: 1
            }
        ]
    };

    const definitions$13 = {
        rpc: {},
        runtime: runtime$q,
        types: {
            AssetApprovalKey: {
                owner: 'AccountId',
                delegate: 'AccountId'
            },
            AssetApproval: {
                amount: 'TAssetBalance',
                deposit: 'TAssetDepositBalance'
            },
            AssetBalance: {
                balance: 'TAssetBalance',
                isFrozen: 'bool',
                isSufficient: 'bool'
            },
            AssetDestroyWitness: {
                accounts: 'Compact<u32>',
                sufficients: 'Compact<u32>',
                approvals: 'Compact<u32>'
            },
            AssetDetails: {
                owner: 'AccountId',
                issuer: 'AccountId',
                admin: 'AccountId',
                freezer: 'AccountId',
                supply: 'TAssetBalance',
                deposit: 'TAssetDepositBalance',
                minBalance: 'TAssetBalance',
                isSufficient: 'bool',
                accounts: 'u32',
                sufficients: 'u32',
                approvals: 'u32',
                isFrozen: 'bool'
            },
            AssetMetadata: {
                deposit: 'TAssetDepositBalance',
                name: 'Vec<u8>',
                symbol: 'Vec<u8>',
                decimals: 'u8',
                isFrozen: 'bool'
            },
            TAssetBalance: 'u64',
            TAssetDepositBalance: 'BalanceOf'
        }
    };

    const runtime$p = {
        AuraApi: [
            {
                methods: {
                    authorities: {
                        description: 'Return the current set of authorities.',
                        params: [],
                        type: 'Vec<AuthorityId>'
                    },
                    slot_duration: {
                        description: 'Returns the slot duration for Aura.',
                        params: [],
                        type: 'SlotDuration'
                    }
                },
                version: 1
            }
        ]
    };

    const definitions$12 = {
        rpc: {},
        runtime: runtime$p,
        types: {
            RawAuraPreDigest: {
                slotNumber: 'u64'
            }
        }
    };

    const definitions$11 = {
        rpc: {},
        types: {
            UncleEntryItem: {
                _enum: {
                    InclusionHeight: 'BlockNumber',
                    Uncle: '(Hash, Option<AccountId>)'
                }
            }
        }
    };

    const rpc$g = {
        epochAuthorship: {
            description: 'Returns data about which slots (primary or secondary) can be claimed in the current epoch with the keys in the keystore',
            isUnsafe: true,
            params: [],
            type: 'HashMap<AuthorityId, EpochAuthorship>'
        }
    };

    const V1_V2_SHARED = {
        current_epoch: {
            description: 'Returns information regarding the current epoch.',
            params: [],
            type: 'Epoch'
        },
        current_epoch_start: {
            description: 'Returns the slot that started the current epoch.',
            params: [],
            type: 'Slot'
        },
        generate_key_ownership_proof: {
            description: 'Generates a proof of key ownership for the given authority in the current epoch.',
            params: [
                {
                    name: 'slot',
                    type: 'Slot'
                },
                {
                    name: 'authorityId',
                    type: 'AuthorityId'
                }
            ],
            type: 'Option<OpaqueKeyOwnershipProof>'
        },
        next_epoch: {
            description: 'Returns information regarding the next epoch (which was already previously announced).',
            params: [],
            type: 'Epoch'
        },
        submit_report_equivocation_unsigned_extrinsic: {
            description: 'Submits an unsigned extrinsic to report an equivocation.',
            params: [
                {
                    name: 'equivocationProof',
                    type: 'BabeEquivocationProof'
                },
                {
                    name: 'keyOwnerProof',
                    type: 'OpaqueKeyOwnershipProof'
                }
            ],
            type: 'Option<Null>'
        }
    };
    const runtime$o = {
        BabeApi: [
            {
                methods: {
                    configuration: {
                        description: 'Return the genesis configuration for BABE. The configuration is only read on genesis.',
                        params: [],
                        type: 'BabeGenesisConfiguration'
                    },
                    ...V1_V2_SHARED
                },
                version: 2
            },
            {
                methods: {
                    configuration: {
                        description: 'Return the configuration for BABE. Version 1.',
                        params: [],
                        type: 'BabeGenesisConfigurationV1'
                    },
                    ...V1_V2_SHARED
                },
                version: 1
            }
        ]
    };

    const definitions$10 = {
        rpc: rpc$g,
        runtime: runtime$o,
        types: {
            AllowedSlots: {
                _enum: ['PrimarySlots', 'PrimaryAndSecondaryPlainSlots', 'PrimaryAndSecondaryVRFSlots']
            },
            BabeAuthorityWeight: 'u64',
            BabeEpochConfiguration: {
                c: '(u64, u64)',
                allowedSlots: 'AllowedSlots'
            },
            BabeBlockWeight: 'u32',
            BabeEquivocationProof: {
                offender: 'AuthorityId',
                slotNumber: 'SlotNumber',
                firstHeader: 'Header',
                secondHeader: 'Header'
            },
            BabeGenesisConfiguration: {
                slotDuration: 'u64',
                epochLength: 'u64',
                c: '(u64, u64)',
                genesisAuthorities: 'Vec<(AuthorityId, BabeAuthorityWeight)>',
                randomness: 'Randomness',
                allowedSlots: 'AllowedSlots'
            },
            BabeGenesisConfigurationV1: {
                slotDuration: 'u64',
                epochLength: 'u64',
                c: '(u64, u64)',
                genesisAuthorities: 'Vec<(AuthorityId, BabeAuthorityWeight)>',
                randomness: 'Randomness',
                secondarySlots: 'bool'
            },
            BabeWeight: 'u64',
            MaybeRandomness: 'Option<Randomness>',
            MaybeVrf: 'Option<VrfData>',
            Epoch: {
                epochIndex: 'u64',
                startSlot: 'Slot',
                duration: 'u64',
                authorities: 'Vec<(AuthorityId, BabeAuthorityWeight)>',
                randomness: 'Hash',
                config: 'BabeEpochConfiguration'
            },
            EpochAuthorship: {
                primary: 'Vec<u64>',
                secondary: 'Vec<u64>',
                secondary_vrf: 'Vec<u64>'
            },
            NextConfigDescriptor: {
                _enum: {
                    V0: 'Null',
                    V1: 'NextConfigDescriptorV1'
                }
            },
            NextConfigDescriptorV1: {
                c: '(u64, u64)',
                allowedSlots: 'AllowedSlots'
            },
            OpaqueKeyOwnershipProof: 'Bytes',
            Randomness: 'Hash',
            RawBabePreDigest: {
                _enum: {
                    Phantom: 'Null',
                    Primary: 'RawBabePreDigestPrimary',
                    SecondaryPlain: 'RawBabePreDigestSecondaryPlain',
                    SecondaryVRF: 'RawBabePreDigestSecondaryVRF'
                }
            },
            RawBabePreDigestPrimary: {
                authorityIndex: 'u32',
                slotNumber: 'SlotNumber',
                vrfOutput: 'VrfOutput',
                vrfProof: 'VrfProof'
            },
            RawBabePreDigestSecondaryPlain: {
                authorityIndex: 'u32',
                slotNumber: 'SlotNumber'
            },
            RawBabePreDigestSecondaryVRF: {
                authorityIndex: 'u32',
                slotNumber: 'SlotNumber',
                vrfOutput: 'VrfOutput',
                vrfProof: 'VrfProof'
            },
            RawBabePreDigestTo159: {
                _enum: {
                    Primary: 'RawBabePreDigestPrimaryTo159',
                    Secondary: 'RawBabePreDigestSecondaryTo159'
                }
            },
            RawBabePreDigestPrimaryTo159: {
                authorityIndex: 'u32',
                slotNumber: 'SlotNumber',
                weight: 'BabeBlockWeight',
                vrfOutput: 'VrfOutput',
                vrfProof: 'VrfProof'
            },
            RawBabePreDigestSecondaryTo159: {
                authorityIndex: 'u32',
                slotNumber: 'SlotNumber',
                weight: 'BabeBlockWeight'
            },
            RawBabePreDigestCompat: {
                _enum: {
                    Zero: 'u32',
                    One: 'u32',
                    Two: 'u32',
                    Three: 'u32'
                }
            },
            SlotNumber: 'u64',
            VrfData: '[u8; 32]',
            VrfOutput: '[u8; 32]',
            VrfProof: '[u8; 64]'
        }
    };

    const definitions$$ = {
        rpc: {},
        types: {
            AccountData: {
                free: 'Balance',
                reserved: 'Balance',
                miscFrozen: 'Balance',
                feeFrozen: 'Balance'
            },
            BalanceLockTo212: {
                id: 'LockIdentifier',
                amount: 'Balance',
                until: 'BlockNumber',
                reasons: 'WithdrawReasons'
            },
            BalanceLock: {
                id: 'LockIdentifier',
                amount: 'Balance',
                reasons: 'Reasons'
            },
            BalanceStatus: {
                _enum: ['Free', 'Reserved']
            },
            Reasons: {
                _enum: ['Fee', 'Misc', 'All']
            },
            ReserveData: {
                id: 'ReserveIdentifier',
                amount: 'Balance'
            },
            ReserveIdentifier: '[u8; 8]',
            VestingSchedule: {
                offset: 'Balance',
                perBlock: 'Balance',
                startingBlock: 'BlockNumber'
            },
            WithdrawReasons: {
                _set: {
                    TransactionPayment: 1,
                    Transfer: 2,
                    Reserve: 4,
                    Fee: 8,
                    Tip: 16
                }
            }
        }
    };

    const rpc$f = {
        getFinalizedHead: {
            description: 'Returns hash of the latest BEEFY finalized block as seen by this client.',
            params: [],
            type: 'H256'
        },
        subscribeJustifications: {
            description: 'Returns the block most recently finalized by BEEFY, alongside its justification.',
            params: [],
            pubsub: [
                'justifications',
                'subscribeJustifications',
                'unsubscribeJustifications'
            ],
            type: 'BeefyVersionedFinalityProof'
        }
    };

    const BEEFY_V1_V3 = {
        beefy_genesis: {
            description: 'Return the block number where BEEFY consensus is enabled/started',
            params: [],
            type: 'Option<BlockNumber>'
        },
        generate_key_ownership_proof: {
            description: 'Generates a proof of key ownership for the given authority in the given set.',
            params: [
                {
                    name: 'setId',
                    type: 'ValidatorSetId'
                },
                {
                    name: 'authorityId',
                    type: 'AuthorityId'
                }
            ],
            type: 'Option<OpaqueKeyOwnershipProof>'
        },
        submit_report_equivocation_unsigned_extrinsic: {
            description: 'Submits an unsigned extrinsic to report an equivocation.',
            params: [
                {
                    name: 'equivocationProof',
                    type: 'BeefyEquivocationProof'
                },
                {
                    name: 'keyOwnerProof',
                    type: 'OpaqueKeyOwnershipProof'
                }
            ],
            type: 'Option<Null>'
        },
        validator_set: {
            description: 'Return the current active BEEFY validator set',
            params: [],
            type: 'Option<ValidatorSet>'
        }
    };
    const BEEFY_MMR_V1 = {
        authority_set_proof: {
            description: 'Return the currently active BEEFY authority set proof.',
            params: [],
            type: 'BeefyAuthoritySet'
        },
        next_authority_set_proof: {
            description: 'Return the next/queued BEEFY authority set proof.',
            params: [],
            type: 'BeefyNextAuthoritySet'
        }
    };
    const runtime$n = {
        BeefyApi: [
            {
                methods: BEEFY_V1_V3,
                version: 3
            },
            {
                methods: BEEFY_V1_V3,
                version: 2
            },
            {
                methods: BEEFY_V1_V3,
                version: 1
            }
        ],
        BeefyMmrApi: [
            {
                methods: BEEFY_MMR_V1,
                version: 1
            }
        ]
    };

    const definitions$_ = {
        rpc: rpc$f,
        runtime: runtime$n,
        types: {
            BeefyAuthoritySet: {
                id: 'u64',
                len: 'u32',
                root: 'H256'
            },
            BeefyCommitment: {
                payload: 'BeefyPayload',
                blockNumber: 'BlockNumber',
                validatorSetId: 'ValidatorSetId'
            },
            BeefyId: '[u8; 33]',
            BeefyEquivocationProof: {
                first: 'BeefyVoteMessage',
                second: 'BeefyVoteMessage'
            },
            BeefySignedCommitment: {
                commitment: 'BeefyCommitment',
                signatures: 'Vec<Option<EcdsaSignature>>'
            },
            BeefyVersionedFinalityProof: {
                _enum: {
                    V0: 'Null',
                    V1: 'BeefySignedCommitment'
                }
            },
            BeefyNextAuthoritySet: {
                id: 'u64',
                len: 'u32',
                root: 'H256'
            },
            BeefyPayload: 'Vec<(BeefyPayloadId, Bytes)>',
            BeefyPayloadId: '[u8;2]',
            BeefyVoteMessage: {
                commitment: 'BeefyCommitment',
                id: 'AuthorityId',
                signature: 'Signature'
            },
            MmrRootHash: 'H256',
            ValidatorSetId: 'u64',
            ValidatorSet: {
                validators: 'Vec<AuthorityId>',
                id: 'ValidatorSetId'
            }
        }
    };

    const runtime$m = {
        Benchmark: [
            {
                methods: {
                    benchmark_metadata: {
                        description: 'Get the benchmark metadata available for this runtime.',
                        params: [
                            {
                                name: 'extra',
                                type: 'bool'
                            }
                        ],
                        type: '(Vec<BenchmarkList>, Vec<StorageInfo>)'
                    },
                    dispatch_benchmark: {
                        description: 'Dispatch the given benchmark.',
                        params: [
                            {
                                name: 'config',
                                type: 'BenchmarkConfig'
                            }
                        ],
                        type: 'Result<Vec<BenchmarkBatch>, Text>'
                    }
                },
                version: 1
            }
        ]
    };

    const definitions$Z = {
        rpc: {},
        runtime: runtime$m,
        types: {
            BenchmarkBatch: {
                pallet: 'Text',
                instance: 'Text',
                benchmark: 'Text',
                results: 'Vec<BenchmarkResult>'
            },
            BenchmarkConfig: {
                pallet: 'Bytes',
                benchmark: 'Bytes',
                selectedComponents: 'Vec<(BenchmarkParameter, u32)>',
                verify: 'bool',
                internalRepeats: 'u32'
            },
            BenchmarkList: {
                pallet: 'Bytes',
                instance: 'Bytes',
                benchmarks: 'Vec<BenchmarkMetadata>'
            },
            BenchmarkMetadata: {
                name: 'Bytes',
                components: 'Vec<(BenchmarkParameter, u32, u32)>'
            },
            BenchmarkParameter: {
                _enum: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
            },
            BenchmarkResult: {
                components: 'Vec<(BenchmarkParameter, u32)>',
                extrinsicTime: 'u128',
                storageRootTime: 'u128',
                reads: 'u32',
                repeatReads: 'u32',
                writes: 'u32',
                repeatWrites: 'u32',
                proofSize: 'u32',
                benchKeys: 'Vec<(Vec<u8>, u32, u32, bool)>'
            }
        }
    };

    const BB_V2_TO_V4 = {
        random_seed: {
            description: 'Generate a random seed.',
            params: [],
            type: 'Hash'
        }
    };
    const BB_V2_TO_V5 = {
        apply_extrinsic: {
            description: 'Apply the given extrinsic.',
            params: [
                {
                    name: 'extrinsic',
                    type: 'Extrinsic'
                }
            ],
            type: 'ApplyExtrinsicResultPre6'
        }
    };
    const BB_V2_TO_V6 = {
        check_inherents: {
            description: 'Check that the inherents are valid.',
            params: [
                {
                    name: 'block',
                    type: 'Block'
                },
                {
                    name: 'data',
                    type: 'InherentData'
                }
            ],
            type: 'CheckInherentsResult'
        },
        inherent_extrinsics: {
            description: 'Generate inherent extrinsics.',
            params: [
                {
                    name: 'inherent',
                    type: 'InherentData'
                }
            ],
            type: 'Vec<Extrinsic>'
        }
    };
    const BB_V3_TO_V6 = {
        finalize_block: {
            description: 'Finish the current block.',
            params: [],
            type: 'Header'
        }
    };
    const runtime$l = {
        BlockBuilder: [
            {
                methods: {
                    apply_extrinsic: {
                        description: 'Apply the given extrinsic.',
                        params: [
                            {
                                name: 'extrinsic',
                                type: 'Extrinsic'
                            }
                        ],
                        type: 'ApplyExtrinsicResult'
                    },
                    ...BB_V2_TO_V6,
                    ...BB_V3_TO_V6
                },
                version: 6
            },
            {
                methods: {
                    ...BB_V2_TO_V5,
                    ...BB_V2_TO_V6,
                    ...BB_V3_TO_V6
                },
                version: 5
            },
            {
                methods: {
                    ...BB_V2_TO_V4,
                    ...BB_V2_TO_V5,
                    ...BB_V2_TO_V6,
                    ...BB_V3_TO_V6
                },
                version: 4
            },
            {
                methods: {
                    ...BB_V2_TO_V4,
                    ...BB_V2_TO_V6,
                    ...BB_V3_TO_V6
                },
                version: 3
            },
            {
                methods: {
                    finalise_block: {
                        description: 'Finish the current block.',
                        params: [],
                        type: 'Header'
                    },
                    ...BB_V2_TO_V4,
                    ...BB_V2_TO_V6
                },
                version: 2
            }
        ]
    };

    const definitions$Y = {
        rpc: {},
        runtime: runtime$l,
        types: {
            CheckInherentsResult: {
                okay: 'bool',
                fatalError: 'bool',
                errors: 'InherentData'
            },
            InherentData: {
                data: 'BTreeMap<InherentIdentifier, Bytes>'
            },
            InherentIdentifier: '[u8; 8]'
        }
    };

    const definitions$X = {
        rpc: {},
        types: {
            CollectiveOrigin: {
                _enum: {
                    Members: '(MemberCount, MemberCount)',
                    Member: 'AccountId'
                }
            },
            MemberCount: 'u32',
            ProposalIndex: 'u32',
            VotesTo230: {
                index: 'ProposalIndex',
                threshold: 'MemberCount',
                ayes: 'Vec<AccountId>',
                nays: 'Vec<AccountId>'
            },
            Votes: {
                index: 'ProposalIndex',
                threshold: 'MemberCount',
                ayes: 'Vec<AccountId>',
                nays: 'Vec<AccountId>',
                end: 'BlockNumber'
            }
        }
    };

    const definitions$W = {
        rpc: {},
        types: {
            AuthorityId: 'AccountId',
            RawVRFOutput: '[u8; 32]'
        }
    };

    const rpc$e = {
        call: {
            deprecated: 'Use the runtime interface `api.call.contractsApi.call` instead',
            description: 'Executes a call to a contract',
            params: [
                {
                    name: 'callRequest',
                    type: 'ContractCallRequest'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'ContractExecResult'
        },
        getStorage: {
            deprecated: 'Use the runtime interface `api.call.contractsApi.getStorage` instead',
            description: 'Returns the value under a specified storage key in a contract',
            params: [
                {
                    name: 'address',
                    type: 'AccountId'
                },
                {
                    name: 'key',
                    type: 'H256'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'Option<Bytes>'
        },
        instantiate: {
            deprecated: 'Use the runtime interface `api.call.contractsApi.instantiate` instead',
            description: 'Instantiate a new contract',
            params: [
                {
                    name: 'request',
                    type: 'InstantiateRequestV1'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'ContractInstantiateResult'
        },
        rentProjection: {
            deprecated: 'Not available in newer versions of the contracts interfaces',
            description: 'Returns the projected time a given contract will be able to sustain paying its rent',
            params: [
                {
                    name: 'address',
                    type: 'AccountId'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'Option<BlockNumber>'
        },
        uploadCode: {
            deprecated: 'Use the runtime interface `api.call.contractsApi.uploadCode` instead',
            description: 'Upload new code without instantiating a contract from it',
            endpoint: 'contracts_upload_code',
            params: [
                {
                    name: 'uploadRequest',
                    type: 'CodeUploadRequest'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'CodeUploadResult'
        }
    };

    const SHARED_V1_V2 = {
        get_storage: {
            description: 'Query a given storage key in a given contract.',
            params: [
                {
                    name: 'address',
                    type: 'AccountId'
                },
                {
                    name: 'key',
                    type: 'Bytes'
                }
            ],
            type: 'Option<Bytes>'
        },
        upload_code: {
            description: 'Upload new code without instantiating a contract from it.',
            params: [
                {
                    name: 'origin',
                    type: 'AccountId'
                },
                {
                    name: 'code',
                    type: 'Bytes'
                },
                {
                    name: 'storageDepositLimit',
                    type: 'Option<Balance>'
                }
            ],
            type: 'CodeUploadResult'
        }
    };
    const runtime$k = {
        ContractsApi: [
            {
                methods: {
                    call: {
                        description: 'Perform a call from a specified account to a given contract.',
                        params: [
                            {
                                name: 'origin',
                                type: 'AccountId'
                            },
                            {
                                name: 'dest',
                                type: 'AccountId'
                            },
                            {
                                name: 'value',
                                type: 'Balance'
                            },
                            {
                                name: 'gasLimit',
                                type: 'Option<WeightV2>'
                            },
                            {
                                name: 'storageDepositLimit',
                                type: 'Option<Balance>'
                            },
                            {
                                name: 'inputData',
                                type: 'Vec<u8>'
                            }
                        ],
                        type: 'ContractExecResult'
                    },
                    instantiate: {
                        description: 'Instantiate a new contract.',
                        params: [
                            {
                                name: 'origin',
                                type: 'AccountId'
                            },
                            {
                                name: 'value',
                                type: 'Balance'
                            },
                            {
                                name: 'gasLimit',
                                type: 'Option<WeightV2>'
                            },
                            {
                                name: 'storageDepositLimit',
                                type: 'Option<Balance>'
                            },
                            {
                                name: 'code',
                                type: 'CodeSource'
                            },
                            {
                                name: 'data',
                                type: 'Bytes'
                            },
                            {
                                name: 'salt',
                                type: 'Bytes'
                            }
                        ],
                        type: 'ContractInstantiateResult'
                    },
                    ...SHARED_V1_V2
                },
                version: 2
            },
            {
                methods: {
                    call: {
                        description: 'Perform a call from a specified account to a given contract.',
                        params: [
                            {
                                name: 'origin',
                                type: 'AccountId'
                            },
                            {
                                name: 'dest',
                                type: 'AccountId'
                            },
                            {
                                name: 'value',
                                type: 'Balance'
                            },
                            {
                                name: 'gasLimit',
                                type: 'u64'
                            },
                            {
                                name: 'storageDepositLimit',
                                type: 'Option<Balance>'
                            },
                            {
                                name: 'inputData',
                                type: 'Vec<u8>'
                            }
                        ],
                        type: 'ContractExecResultU64'
                    },
                    instantiate: {
                        description: 'Instantiate a new contract.',
                        params: [
                            {
                                name: 'origin',
                                type: 'AccountId'
                            },
                            {
                                name: 'value',
                                type: 'Balance'
                            },
                            {
                                name: 'gasLimit',
                                type: 'u64'
                            },
                            {
                                name: 'storageDepositLimit',
                                type: 'Option<Balance>'
                            },
                            {
                                name: 'code',
                                type: 'CodeSource'
                            },
                            {
                                name: 'data',
                                type: 'Bytes'
                            },
                            {
                                name: 'salt',
                                type: 'Bytes'
                            }
                        ],
                        type: 'ContractInstantiateResultU64'
                    },
                    ...SHARED_V1_V2
                },
                version: 1
            }
        ]
    };

    const definitions$V = {
        rpc: rpc$e,
        runtime: runtime$k,
        types: {
            AliveContractInfo: {
                trieId: 'TrieId',
                storageSize: 'u32',
                pairCount: 'u32',
                codeHash: 'CodeHash',
                rentAllowance: 'Balance',
                rentPaid: 'Balance',
                deductBlock: 'BlockNumber',
                lastWrite: 'Option<BlockNumber>',
                _reserved: 'Option<Null>'
            },
            CodeHash: 'Hash',
            CodeSource: {
                _enum: {
                    Upload: 'Bytes',
                    Existing: 'Hash'
                }
            },
            CodeUploadRequest: {
                origin: 'AccountId',
                code: 'Bytes',
                storageDepositLimit: 'Option<Balance>'
            },
            CodeUploadResult: 'Result<CodeUploadResultValue, DispatchError>',
            CodeUploadResultValue: {
                codeHash: 'CodeHash',
                deposit: 'Balance'
            },
            ContractCallRequest: {
                origin: 'AccountId',
                dest: 'AccountId',
                value: 'Balance',
                gasLimit: 'u64',
                storageDepositLimit: 'Option<Balance>',
                inputData: 'Bytes'
            },
            ContractExecResultSuccessTo255: {
                status: 'u8',
                data: 'Raw'
            },
            ContractExecResultTo255: {
                _enum: {
                    Success: 'ContractExecResultSuccessTo255',
                    Error: 'Null'
                }
            },
            ContractExecResultSuccessTo260: {
                flags: 'ContractReturnFlags',
                data: 'Bytes',
                gasConsumed: 'u64'
            },
            ContractExecResultTo260: {
                _enum: {
                    Success: 'ContractExecResultSuccessTo260',
                    Error: 'Null'
                }
            },
            ContractExecResultOk: {
                flags: 'ContractReturnFlags',
                data: 'Bytes'
            },
            ContractExecResultResult: 'Result<ContractExecResultOk, DispatchError>',
            ContractExecResultTo267: {
                gasConsumed: 'u64',
                debugMessage: 'Text',
                result: 'ContractExecResultResult'
            },
            ContractExecResult: {
                gasConsumed: 'Weight',
                gasRequired: 'Weight',
                storageDeposit: 'StorageDeposit',
                debugMessage: 'Text',
                result: 'ContractExecResultResult'
            },
            ContractExecResultU64: {
                gasConsumed: 'u64',
                gasRequired: 'u64',
                storageDeposit: 'StorageDeposit',
                debugMessage: 'Text',
                result: 'ContractExecResultResult'
            },
            ContractInfo: {
                _enum: {
                    Alive: 'AliveContractInfo',
                    Tombstone: 'TombstoneContractInfo'
                }
            },
            ContractCallFlags: {
                _set: {
                    _bitLength: 32,
                    ForwardInput: 1,
                    CloneInput: 2,
                    TailCall: 4,
                    AllowReentry: 8
                }
            },
            ContractReturnFlags: {
                _set: {
                    _bitLength: 32,
                    Revert: 1
                }
            },
            ContractStorageKey: '[u8; 32]',
            DeletedContract: {
                pairCount: 'u32',
                trieId: 'TrieId'
            },
            ExecReturnValue: {
                flags: 'ContractReturnFlags',
                data: 'Bytes'
            },
            Gas: 'u64',
            HostFnWeightsTo264: {
                caller: 'Weight',
                address: 'Weight',
                gasLeft: 'Weight',
                balance: 'Weight',
                valueTransferred: 'Weight',
                minimumBalance: 'Weight',
                tombstoneDeposit: 'Weight',
                rentAllowance: 'Weight',
                blockNumber: 'Weight',
                now: 'Weight',
                weightToFee: 'Weight',
                gas: 'Weight',
                input: 'Weight',
                inputPerByte: 'Weight',
                return: 'Weight',
                returnPerByte: 'Weight',
                terminate: 'Weight',
                restoreTo: 'Weight',
                restoreToPerDelta: 'Weight',
                random: 'Weight',
                depositEvent: 'Weight',
                depositEventPerTopic: 'Weight',
                depositEventPerByte: 'Weight',
                setRentAllowance: 'Weight',
                setStorage: 'Weight',
                setStoragePerByte: 'Weight',
                clearStorage: 'Weight',
                getStorage: 'Weight',
                getStoragePerByte: 'Weight',
                transfer: 'Weight',
                call: 'Weight',
                callTransferSurcharge: 'Weight',
                callPerInputByte: 'Weight',
                callPerOutputByte: 'Weight',
                instantiate: 'Weight',
                instantiatePerInputByte: 'Weight',
                instantiatePerOutputByte: 'Weight',
                hashSha2256: 'Weight',
                hashSha2256PerByte: 'Weight',
                hashKeccak256: 'Weight',
                hashKeccak256PerByte: 'Weight',
                hashBlake2256: 'Weight',
                hashBlake2256PerByte: 'Weight',
                hashBlake2128: 'Weight',
                hashBlake2128PerByte: 'Weight'
            },
            HostFnWeights: {
                caller: 'Weight',
                address: 'Weight',
                gasLeft: 'Weight',
                balance: 'Weight',
                valueTransferred: 'Weight',
                minimumBalance: 'Weight',
                tombstoneDeposit: 'Weight',
                rentAllowance: 'Weight',
                blockNumber: 'Weight',
                now: 'Weight',
                weightToFee: 'Weight',
                gas: 'Weight',
                input: 'Weight',
                inputPerByte: 'Weight',
                return: 'Weight',
                returnPerByte: 'Weight',
                terminate: 'Weight',
                terminatePerCodeByte: 'Weight',
                restoreTo: 'Weight',
                restoreToPerCallerCodeByte: 'Weight',
                restoreToPerTombstoneCodeByte: 'Weight',
                restoreToPerDelta: 'Weight',
                random: 'Weight',
                depositEvent: 'Weight',
                depositEventPerTopic: 'Weight',
                depositEventPerByte: 'Weight',
                setRentAllowance: 'Weight',
                setStorage: 'Weight',
                setStoragePerByte: 'Weight',
                clearStorage: 'Weight',
                getStorage: 'Weight',
                getStoragePerByte: 'Weight',
                transfer: 'Weight',
                call: 'Weight',
                callPerCodeByte: 'Weight',
                callTransferSurcharge: 'Weight',
                callPerInputByte: 'Weight',
                callPerOutputByte: 'Weight',
                instantiate: 'Weight',
                instantiatePerCodeByte: 'Weight',
                instantiatePerInputByte: 'Weight',
                instantiatePerOutputByte: 'Weight',
                instantiatePerSaltByte: 'Weight',
                hashSha2256: 'Weight',
                hashSha2256PerByte: 'Weight',
                hashKeccak256: 'Weight',
                hashKeccak256PerByte: 'Weight',
                hashBlake2256: 'Weight',
                hashBlake2256PerByte: 'Weight',
                hashBlake2128: 'Weight',
                hashBlake2128PerByte: 'Weight',
                rentParams: 'Weight'
            },
            InstantiateRequestV1: {
                origin: 'AccountId',
                value: 'Balance',
                gasLimit: 'Gas',
                code: 'Bytes',
                data: 'Bytes',
                salt: 'Bytes'
            },
            InstantiateRequestV2: {
                _fallback: 'InstantiateRequestV1',
                origin: 'AccountId',
                value: 'Balance',
                gasLimit: 'Gas',
                storageDepositLimit: 'Option<Balance>',
                code: 'Bytes',
                data: 'Bytes',
                salt: 'Bytes'
            },
            InstantiateRequest: {
                _fallback: 'InstantiateRequestV2',
                origin: 'AccountId',
                value: 'Balance',
                gasLimit: 'Gas',
                storageDepositLimit: 'Option<Balance>',
                code: 'CodeSource',
                data: 'Bytes',
                salt: 'Bytes'
            },
            ContractInstantiateResultTo267: 'Result<InstantiateReturnValueTo267, Null>',
            ContractInstantiateResultTo299: 'Result<InstantiateReturnValueOk, Null>',
            ContractInstantiateResult: {
                gasConsumed: 'WeightV2',
                gasRequired: 'WeightV2',
                storageDeposit: 'StorageDeposit',
                debugMessage: 'Text',
                result: 'InstantiateReturnValue'
            },
            ContractInstantiateResultU64: {
                _fallback: 'ContractInstantiateResultTo299',
                gasConsumed: 'u64',
                gasRequired: 'u64',
                storageDeposit: 'StorageDeposit',
                debugMessage: 'Text',
                result: 'InstantiateReturnValue'
            },
            InstantiateReturnValueTo267: {
                result: 'ExecReturnValue',
                accountId: 'AccountId',
                rentProjection: 'Option<RentProjection>'
            },
            InstantiateReturnValueOk: {
                result: 'ExecReturnValue',
                accountId: 'AccountId'
            },
            InstantiateReturnValue: 'Result<InstantiateReturnValueOk, DispatchError>',
            InstructionWeights: {
                i64const: 'u32',
                i64load: 'u32',
                i64store: 'u32',
                select: 'u32',
                rIf: 'u32',
                br: 'u32',
                brIf: 'u32',
                brIable: 'u32',
                brIablePerEntry: 'u32',
                call: 'u32',
                callIndirect: 'u32',
                callIndirectPerParam: 'u32',
                localGet: 'u32',
                localSet: 'u32',
                local_tee: 'u32',
                globalGet: 'u32',
                globalSet: 'u32',
                memoryCurrent: 'u32',
                memoryGrow: 'u32',
                i64clz: 'u32',
                i64ctz: 'u32',
                i64popcnt: 'u32',
                i64eqz: 'u32',
                i64extendsi32: 'u32',
                i64extendui32: 'u32',
                i32wrapi64: 'u32',
                i64eq: 'u32',
                i64ne: 'u32',
                i64lts: 'u32',
                i64ltu: 'u32',
                i64gts: 'u32',
                i64gtu: 'u32',
                i64les: 'u32',
                i64leu: 'u32',
                i64ges: 'u32',
                i64geu: 'u32',
                i64add: 'u32',
                i64sub: 'u32',
                i64mul: 'u32',
                i64divs: 'u32',
                i64divu: 'u32',
                i64rems: 'u32',
                i64remu: 'u32',
                i64and: 'u32',
                i64or: 'u32',
                i64xor: 'u32',
                i64shl: 'u32',
                i64shrs: 'u32',
                i64shru: 'u32',
                i64rotl: 'u32',
                i64rotr: 'u32'
            },
            LimitsTo264: {
                eventTopics: 'u32',
                stackHeight: 'u32',
                globals: 'u32',
                parameters: 'u32',
                memoryPages: 'u32',
                tableSize: 'u32',
                brTableSize: 'u32',
                subjectLen: 'u32',
                codeSize: 'u32'
            },
            Limits: {
                eventTopics: 'u32',
                stackHeight: 'u32',
                globals: 'u32',
                parameters: 'u32',
                memoryPages: 'u32',
                tableSize: 'u32',
                brTableSize: 'u32',
                subjectLen: 'u32'
            },
            PrefabWasmModule: {
                scheduleVersion: 'Compact<u32>',
                initial: 'Compact<u32>',
                maximum: 'Compact<u32>',
                refcount: 'Compact<u64>',
                _reserved: 'Option<Null>',
                code: 'Bytes',
                originalCodeLen: 'u32'
            },
            RentProjection: {
                _enum: {
                    EvictionAt: 'BlockNumber',
                    NoEviction: 'Null'
                }
            },
            ScheduleTo212: {
                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'
            },
            ScheduleTo258: {
                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'
            },
            ScheduleTo264: {
                version: 'u32',
                enablePrintln: 'bool',
                limits: 'LimitsTo264',
                instructionWeights: 'InstructionWeights',
                hostFnWeights: 'HostFnWeightsTo264'
            },
            Schedule: {
                version: 'u32',
                enablePrintln: 'bool',
                limits: 'Limits',
                instructionWeights: 'InstructionWeights',
                hostFnWeights: 'HostFnWeights'
            },
            SeedOf: 'Hash',
            StorageDeposit: {
                _enum: {
                    Refund: 'Balance',
                    Charge: 'Balance'
                }
            },
            TombstoneContractInfo: 'Hash',
            TrieId: 'Bytes'
        }
    };

    const AllConvictions = [
        'None',
        'Locked1x',
        'Locked2x',
        'Locked3x',
        'Locked4x',
        'Locked5x',
        'Locked6x'
    ];
    const definitions$U = {
        rpc: {},
        types: {
            AccountVote: {
                _enum: {
                    Standard: 'AccountVoteStandard',
                    Split: 'AccountVoteSplit'
                }
            },
            AccountVoteSplit: {
                aye: 'Balance',
                nay: 'Balance'
            },
            AccountVoteStandard: {
                vote: 'Vote',
                balance: 'Balance'
            },
            Conviction: {
                _enum: AllConvictions
            },
            Delegations: {
                votes: 'Balance',
                capital: 'Balance'
            },
            PreimageStatus: {
                _enum: {
                    Missing: 'BlockNumber',
                    Available: 'PreimageStatusAvailable'
                }
            },
            PreimageStatusAvailable: {
                data: 'Bytes',
                provider: 'AccountId',
                deposit: 'Balance',
                since: 'BlockNumber',
                expiry: 'Option<BlockNumber>'
            },
            PriorLock: '(BlockNumber, Balance)',
            PropIndex: 'u32',
            Proposal: 'Call',
            ProxyState: {
                _enum: {
                    Open: 'AccountId',
                    Active: 'AccountId'
                }
            },
            ReferendumIndex: 'u32',
            ReferendumInfoTo239: {
                end: 'BlockNumber',
                proposalHash: 'Hash',
                threshold: 'VoteThreshold',
                delay: 'BlockNumber'
            },
            ReferendumInfo: {
                _enum: {
                    Ongoing: 'ReferendumStatus',
                    Finished: 'ReferendumInfoFinished'
                }
            },
            ReferendumInfoFinished: {
                approved: 'bool',
                end: 'BlockNumber'
            },
            ReferendumStatus: {
                end: 'BlockNumber',
                proposalHash: 'Hash',
                threshold: 'VoteThreshold',
                delay: 'BlockNumber',
                tally: 'Tally'
            },
            Tally: {
                ayes: 'Balance',
                nays: 'Balance',
                turnout: 'Balance'
            },
            Voting: {
                _enum: {
                    Direct: 'VotingDirect',
                    Delegating: 'VotingDelegating'
                }
            },
            VotingDirect: {
                votes: 'Vec<VotingDirectVote>',
                delegations: 'Delegations',
                prior: 'PriorLock'
            },
            VotingDirectVote: '(ReferendumIndex, AccountVote)',
            VotingDelegating: {
                balance: 'Balance',
                target: 'AccountId',
                conviction: 'Conviction',
                delegations: 'Delegations',
                prior: 'PriorLock'
            }
        }
    };

    const rpc$d = {
        getBlockStats: {
            description: 'Reexecute the specified `block_hash` and gather statistics while doing so',
            isUnsafe: true,
            params: [
                {
                    isHistoric: true,
                    name: 'at',
                    type: 'Hash'
                }
            ],
            type: 'Option<BlockStats>'
        }
    };

    const definitions$T = {
        rpc: rpc$d,
        types: {
            BlockStats: {
                witnessLen: 'u64',
                witnessCompactLen: 'u64',
                blockLen: 'u64',
                blockNumExtrinsics: 'u64'
            }
        }
    };

    const runtime$j = {
        AuthorityDiscoveryApi: [
            {
                methods: {
                    authorities: {
                        description: 'Retrieve authority identifiers of the current and next authority set.',
                        params: [],
                        type: 'Vec<AuthorityId>'
                    }
                },
                version: 1
            }
        ]
    };

    const definitions$S = {
        rpc: {},
        runtime: runtime$j,
        types: {}
    };

    const definitions$R = {
        rpc: {},
        types: {
            ApprovalFlag: 'u32',
            DefunctVoter: {
                who: 'AccountId',
                voteCount: 'Compact<u32>',
                candidateCount: 'Compact<u32>'
            },
            Renouncing: {
                _enum: {
                    Member: 'Null',
                    RunnerUp: 'Null',
                    Candidate: 'Compact<u32>'
                }
            },
            SetIndex: 'u32',
            Vote: 'GenericVote',
            VoteIndex: 'u32',
            VoterInfo: {
                lastActive: 'VoteIndex',
                lastWin: 'VoteIndex',
                pot: 'Balance',
                stake: 'Balance'
            },
            VoteThreshold: {
                _enum: [
                    'Super Majority Approve',
                    'Super Majority Against',
                    'Simple Majority'
                ]
            }
        }
    };

    const rpc$c = {
        createBlock: {
            description: 'Instructs the manual-seal authorship task to create a new block',
            params: [
                {
                    name: 'createEmpty',
                    type: 'bool'
                },
                {
                    name: 'finalize',
                    type: 'bool'
                },
                {
                    isOptional: true,
                    name: 'parentHash',
                    type: 'BlockHash'
                }
            ],
            type: 'CreatedBlock'
        },
        finalizeBlock: {
            description: 'Instructs the manual-seal authorship task to finalize a block',
            params: [
                {
                    name: 'hash',
                    type: 'BlockHash'
                },
                {
                    isOptional: true,
                    name: 'justification',
                    type: 'Justification'
                }
            ],
            type: 'bool'
        }
    };

    const definitions$Q = {
        rpc: rpc$c,
        types: {
            CreatedBlock: {
                _alias: {
                    blockHash: 'hash'
                },
                blockHash: 'BlockHash',
                aux: 'ImportedAux'
            },
            ImportedAux: {
                headerOnly: 'bool',
                clearJustificationRequests: 'bool',
                needsJustification: 'bool',
                badJustification: 'bool',
                needsFinalityProof: 'bool',
                isNewBest: 'bool'
            }
        }
    };

    const definitions$P = {
        rpc: {},
        types: {
            EvmAccount: {
                nonce: 'u256',
                balance: 'u256'
            },
            EvmCallInfo: {
                exitReason: 'ExitReason',
                value: 'Bytes',
                usedGas: 'U256',
                logs: 'Vec<EvmLog>'
            },
            EvmCreateInfo: {
                exitReason: 'ExitReason',
                value: 'H160',
                usedGas: 'U256',
                logs: 'Vec<EvmLog>'
            },
            EvmCallInfoV2: {
                exitReason: 'ExitReason',
                value: 'Bytes',
                usedGas: 'U256',
                weightInfo: 'Option<EvmWeightInfo>',
                logs: 'Vec<EvmLog>'
            },
            EvmCreateInfoV2: {
                exitReason: 'ExitReason',
                value: 'H160',
                usedGas: 'U256',
                weightInfo: 'Option<EvmWeightInfo>',
                logs: 'Vec<EvmLog>'
            },
            EvmLog: {
                address: 'H160',
                topics: 'Vec<H256>',
                data: 'Bytes'
            },
            EvmVicinity: {
                gasPrice: 'u256',
                origin: 'H160'
            },
            EvmWeightInfo: {
                refTimeLimit: 'Option<u64>',
                proofSizeLimit: 'Option<u64>',
                refTimeUsage: 'Option<u64>',
                proofSizeUsage: 'Option<u64>'
            },
            ExitError: {
                _enum: {
                    StackUnderflow: 'Null',
                    StackOverflow: 'Null',
                    InvalidJump: 'Null',
                    InvalidRange: 'Null',
                    DesignatedInvalid: 'Null',
                    CallTooDeep: 'Null',
                    CreateCollision: 'Null',
                    CreateContractLimit: 'Null',
                    OutOfOffset: 'Null',
                    OutOfGas: 'Null',
                    OutOfFund: 'Null',
                    PCUnderflow: 'Null',
                    CreateEmpty: 'Null',
                    Other: 'Text'
                }
            },
            ExitFatal: {
                _enum: {
                    NotSupported: 'Null',
                    UnhandledInterrupt: 'Null',
                    CallErrorAsFatal: 'ExitError',
                    Other: 'Text'
                }
            },
            ExitReason: {
                _enum: {
                    Succeed: 'ExitSucceed',
                    Error: 'ExitError',
                    Revert: 'ExitRevert',
                    Fatal: 'ExitFatal'
                }
            },
            ExitRevert: {
                _enum: ['Reverted']
            },
            ExitSucceed: {
                _enum: ['Stopped', 'Returned', 'Suicided']
            }
        }
    };

    const definitions$O = {
        rpc: {},
        types: {
            Extrinsic: 'GenericExtrinsic',
            ExtrinsicEra: 'GenericExtrinsicEra',
            ExtrinsicPayload: 'GenericExtrinsicPayload',
            ExtrinsicSignature: 'MultiSignature',
            ExtrinsicV4: 'GenericExtrinsicV4',
            ExtrinsicPayloadV4: 'GenericExtrinsicPayloadV4',
            ExtrinsicSignatureV4: 'GenericExtrinsicSignatureV4',
            ExtrinsicUnknown: 'GenericExtrinsicUnknown',
            ExtrinsicPayloadUnknown: 'GenericExtrinsicPayloadUnknown',
            Era: 'ExtrinsicEra',
            ImmortalEra: 'GenericImmortalEra',
            MortalEra: 'GenericMortalEra',
            AnySignature: 'H512',
            MultiSignature: {
                _enum: {
                    Ed25519: 'Ed25519Signature',
                    Sr25519: 'Sr25519Signature',
                    Ecdsa: 'EcdsaSignature'
                }
            },
            Signature: 'H512',
            SignerPayload: 'GenericSignerPayload',
            EcdsaSignature: '[u8; 65]',
            Ed25519Signature: 'H512',
            Sr25519Signature: 'H512'
        }
    };

    const runtime$i = {
        FungiblesApi: [
            {
                methods: {
                    query_account_balances: {
                        description: 'Returns the list of all `MultiAsset` that an `AccountId` has',
                        params: [
                            {
                                name: 'account',
                                type: 'AccountId'
                            }
                        ],
                        type: 'Result<Vec<XcmV3MultiAsset>, FungiblesAccessError>'
                    }
                },
                version: 1
            },
            {
                methods: {
                    query_account_balances: {
                        description: 'Returns the list of all `MultiAsset` that an `AccountId` has',
                        params: [
                            {
                                name: 'account',
                                type: 'AccountId'
                            }
                        ],
                        type: 'Result<XcmVersionedMultiAssets, FungiblesAccessError>'
                    }
                },
                version: 2
            }
        ]
    };

    const definitions$N = {
        rpc: {},
        runtime: runtime$i,
        types: {
            FungiblesAccessError: {
                _enum: ['AssetIdConversionFailed', 'AmountToBalanceConversionFailed']
            }
        }
    };

    const definitions$M = {
        rpc: {},
        types: {
            AssetOptions: {
                initalIssuance: 'Compact<Balance>',
                permissions: 'PermissionLatest'
            },
            Owner: {
                _enum: {
                    None: 'Null',
                    Address: 'AccountId'
                }
            },
            PermissionsV1: {
                update: 'Owner',
                mint: 'Owner',
                burn: 'Owner'
            },
            PermissionVersions: {
                _enum: {
                    V1: 'PermissionsV1'
                }
            },
            PermissionLatest: 'PermissionsV1'
        }
    };

    const definitions$L = {
        rpc: {},
        types: {
            ActiveGilt: {
                proportion: 'Perquintill',
                amount: 'Balance',
                who: 'AccountId',
                expiry: 'BlockNumber'
            },
            ActiveGiltsTotal: {
                frozen: 'Balance',
                proportion: 'Perquintill',
                index: 'ActiveIndex',
                target: 'Perquintill'
            },
            ActiveIndex: 'u32',
            GiltBid: {
                amount: 'Balance',
                who: 'AccountId'
            }
        }
    };

    const rpc$b = {
        proveFinality: {
            description: 'Prove finality for the given block number, returning the Justification for the last block in the set.',
            params: [
                {
                    name: 'blockNumber',
                    type: 'BlockNumber'
                }
            ],
            type: 'Option<EncodedFinalityProofs>'
        },
        roundState: {
            description: 'Returns the state of the current best round state as well as the ongoing background rounds',
            params: [],
            type: 'ReportedRoundStates'
        },
        subscribeJustifications: {
            description: 'Subscribes to grandpa justifications',
            params: [],
            pubsub: [
                'justifications',
                'subscribeJustifications',
                'unsubscribeJustifications'
            ],
            type: 'JustificationNotification'
        }
    };

    const GRANDPA_V2_V3 = {
        generate_key_ownership_proof: {
            description: 'Generates a proof of key ownership for the given authority in the given set.',
            params: [
                {
                    name: 'setId',
                    type: 'SetId'
                },
                {
                    name: 'authorityId',
                    type: 'AuthorityId'
                }
            ],
            type: 'Option<OpaqueKeyOwnershipProof>'
        },
        grandpa_authorities: {
            description: 'Get the current GRANDPA authorities and weights. This should not change except for when changes are scheduled and the corresponding delay has passed.',
            params: [],
            type: 'AuthorityList'
        },
        submit_report_equivocation_unsigned_extrinsic: {
            description: 'Submits an unsigned extrinsic to report an equivocation.',
            params: [
                {
                    name: 'equivocationProof',
                    type: 'GrandpaEquivocationProof'
                },
                {
                    name: 'keyOwnerProof',
                    type: 'OpaqueKeyOwnershipProof'
                }
            ],
            type: 'Option<Null>'
        }
    };
    const runtime$h = {
        GrandpaApi: [
            {
                methods: {
                    current_set_id: {
                        description: 'Get current GRANDPA authority set id.',
                        params: [],
                        type: 'SetId'
                    },
                    ...GRANDPA_V2_V3
                },
                version: 3
            },
            {
                methods: GRANDPA_V2_V3,
                version: 2
            }
        ]
    };

    const definitions$K = {
        rpc: rpc$b,
        runtime: runtime$h,
        types: {
            AuthorityIndex: 'u64',
            AuthorityList: 'Vec<NextAuthority>',
            AuthoritySet: {
                currentAuthorities: 'AuthorityList',
                setId: 'u64',
                pendingStandardChanges: 'ForkTreePendingChange',
                pendingForcedChanges: 'Vec<PendingChange>',
                authoritySetChanges: 'AuthoritySetChanges'
            },
            ForkTreePendingChange: {
                roots: 'Vec<ForkTreePendingChangeNode>',
                bestFinalizedNumber: 'Option<BlockNumber>'
            },
            ForkTreePendingChangeNode: {
                hash: 'BlockHash',
                number: 'BlockNumber',
                data: 'PendingChange',
                children: 'Vec<ForkTreePendingChangeNode>'
            },
            AuthoritySetChange: '(U64, BlockNumber)',
            AuthoritySetChanges: 'Vec<AuthoritySetChange>',
            AuthorityWeight: 'u64',
            DelayKind: {
                _enum: {
                    Finalized: 'Null',
                    Best: 'DelayKindBest'
                }
            },
            DelayKindBest: {
                medianLastFinalized: 'BlockNumber'
            },
            EncodedFinalityProofs: 'Bytes',
            GrandpaEquivocation: {
                _enum: {
                    Prevote: 'GrandpaEquivocationValue',
                    Precommit: 'GrandpaEquivocationValue'
                }
            },
            GrandpaEquivocationProof: {
                setId: 'SetId',
                equivocation: 'GrandpaEquivocation'
            },
            GrandpaEquivocationValue: {
                roundNumber: 'u64',
                identity: 'AuthorityId',
                first: '(GrandpaPrevote, AuthoritySignature)',
                second: '(GrandpaPrevote, AuthoritySignature)'
            },
            GrandpaPrevote: {
                targetHash: 'Hash',
                targetNumber: 'BlockNumber'
            },
            GrandpaCommit: {
                targetHash: 'BlockHash',
                targetNumber: 'BlockNumber',
                precommits: 'Vec<GrandpaSignedPrecommit>'
            },
            GrandpaPrecommit: {
                targetHash: 'BlockHash',
                targetNumber: 'BlockNumber'
            },
            GrandpaSignedPrecommit: {
                precommit: 'GrandpaPrecommit',
                signature: 'AuthoritySignature',
                id: 'AuthorityId'
            },
            GrandpaJustification: {
                round: 'u64',
                commit: 'GrandpaCommit',
                votesAncestries: 'Vec<Header>'
            },
            JustificationNotification: 'Bytes',
            KeyOwnerProof: 'MembershipProof',
            NextAuthority: '(AuthorityId, AuthorityWeight)',
            PendingChange: {
                nextAuthorities: 'AuthorityList',
                delay: 'BlockNumber',
                canonHeight: 'BlockNumber',
                canonHash: 'BlockHash',
                delayKind: 'DelayKind'
            },
            PendingPause: {
                scheduledAt: 'BlockNumber',
                delay: 'BlockNumber'
            },
            PendingResume: {
                scheduledAt: 'BlockNumber',
                delay: 'BlockNumber'
            },
            Precommits: {
                currentWeight: 'u32',
                missing: 'BTreeSet<AuthorityId>'
            },
            Prevotes: {
                currentWeight: 'u32',
                missing: 'BTreeSet<AuthorityId>'
            },
            ReportedRoundStates: {
                setId: 'u32',
                best: 'RoundState',
                background: 'Vec<RoundState>'
            },
            RoundState: {
                round: 'u32',
                totalWeight: 'u32',
                thresholdWeight: 'u32',
                prevotes: 'Prevotes',
                precommits: 'Precommits'
            },
            SetId: 'u64',
            StoredPendingChange: {
                scheduledAt: 'BlockNumber',
                delay: 'BlockNumber',
                nextAuthorities: 'AuthorityList'
            },
            StoredState: {
                _enum: {
                    Live: 'Null',
                    PendingPause: 'PendingPause',
                    Paused: 'Null',
                    PendingResume: 'PendingResume'
                }
            }
        }
    };

    const definitions$J = {
        rpc: {},
        types: {
            IdentityFields: {
                _set: {
                    _bitLength: 64,
                    Display: 1,
                    Legal: 2,
                    Web: 4,
                    Riot: 8,
                    Email: 16,
                    PgpFingerprint: 32,
                    Image: 64,
                    Twitter: 128
                }
            },
            IdentityInfoAdditional: '(Data, Data)',
            IdentityInfoTo198: {
                additional: 'Vec<IdentityInfoAdditional>',
                display: 'Data',
                legal: 'Data',
                web: 'Data',
                riot: 'Data',
                email: 'Data',
                pgpFingerprint: 'Option<H160>',
                image: 'Data'
            },
            IdentityInfo: {
                _fallback: 'IdentityInfoTo198',
                additional: 'Vec<IdentityInfoAdditional>',
                display: 'Data',
                legal: 'Data',
                web: 'Data',
                riot: 'Data',
                email: 'Data',
                pgpFingerprint: 'Option<H160>',
                image: 'Data',
                twitter: 'Data'
            },
            IdentityJudgement: {
                _enum: {
                    Unknown: 'Null',
                    FeePaid: 'Balance',
                    Reasonable: 'Null',
                    KnownGood: 'Null',
                    OutOfDate: 'Null',
                    LowQuality: 'Null',
                    Erroneous: 'Null'
                }
            },
            RegistrationJudgement: '(RegistrarIndex, IdentityJudgement)',
            RegistrationTo198: {
                judgements: 'Vec<RegistrationJudgement>',
                deposit: 'Balance',
                info: 'IdentityInfoTo198'
            },
            Registration: {
                _fallback: 'RegistrationTo198',
                judgements: 'Vec<RegistrationJudgement>',
                deposit: 'Balance',
                info: 'IdentityInfo'
            },
            RegistrarIndex: 'u32',
            RegistrarInfo: {
                account: 'AccountId',
                fee: 'Balance',
                fields: 'IdentityFields'
            }
        }
    };

    const definitions$I = {
        rpc: {},
        types: {
            AuthIndex: 'u32',
            AuthoritySignature: 'Signature',
            Heartbeat: {
                blockNumber: 'BlockNumber',
                networkState: 'OpaqueNetworkState',
                sessionIndex: 'SessionIndex',
                authorityIndex: 'AuthIndex',
                validatorsLen: 'u32'
            },
            HeartbeatTo244: {
                blockNumber: 'BlockNumber',
                networkState: 'OpaqueNetworkState',
                sessionIndex: 'SessionIndex',
                authorityIndex: 'AuthIndex'
            },
            OpaqueMultiaddr: 'Opaque<Bytes>',
            OpaquePeerId: 'Opaque<Bytes>',
            OpaqueNetworkState: {
                peerId: 'OpaquePeerId',
                externalAddresses: 'Vec<OpaqueMultiaddr>'
            }
        }
    };

    const definitions$H = {
        rpc: {},
        types: {
            CallIndex: '(u8, u8)',
            LotteryConfig: {
                price: 'Balance',
                start: 'BlockNumber',
                length: 'BlockNumber',
                delay: 'BlockNumber',
                repeat: 'bool'
            }
        }
    };

    const rpc$a = {
        generateProof: {
            description: 'Generate MMR proof for the given block numbers.',
            params: [
                {
                    name: 'blockNumbers',
                    type: 'Vec<u64>'
                },
                {
                    isOptional: true,
                    name: 'bestKnownBlockNumber',
                    type: 'u64'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'MmrLeafBatchProof'
        },
        root: {
            description: 'Get the MMR root hash for the current best block.',
            params: [
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'MmrHash'
        },
        verifyProof: {
            description: 'Verify an MMR proof',
            params: [
                {
                    name: 'proof',
                    type: 'MmrLeafBatchProof'
                }
            ],
            type: 'bool'
        },
        verifyProofStateless: {
            description: 'Verify an MMR proof statelessly given an mmr_root',
            params: [
                {
                    name: 'root',
                    type: 'MmrHash'
                },
                {
                    name: 'proof',
                    type: 'MmrLeafBatchProof'
                }
            ],
            type: 'bool'
        }
    };

    const MMR_V2 = {
        generate_proof: {
            description: 'Generate MMR proof for the given block numbers.',
            params: [
                {
                    name: 'blockNumbers',
                    type: 'Vec<BlockNumber>'
                },
                {
                    name: 'bestKnownBlockNumber',
                    type: 'Option<BlockNumber>'
                }
            ],
            type: 'Result<(Vec<MmrEncodableOpaqueLeaf>, MmrBatchProof), MmrError>'
        },
        root: {
            description: 'Return the on-chain MMR root hash.',
            params: [],
            type: 'Result<Hash, MmrError>'
        },
        verify_proof: {
            description: 'Verify MMR proof against on-chain MMR.',
            params: [
                {
                    name: 'leaves',
                    type: 'Vec<MmrEncodableOpaqueLeaf>'
                },
                {
                    name: 'proof',
                    type: 'MmrBatchProof'
                }
            ],
            type: 'Result<(), MmrError>'
        },
        verify_proof_stateless: {
            description: 'Verify MMR proof against given root hash.',
            params: [
                {
                    name: 'root',
                    type: 'Hash'
                },
                {
                    name: 'leaves',
                    type: 'Vec<MmrEncodableOpaqueLeaf>'
                },
                {
                    name: 'proof',
                    type: 'MmrBatchProof'
                }
            ],
            type: 'Result<(), MmrError>'
        }
    };
    const MMR_V1 = {
        generate_batch_proof: {
            description: 'Generate MMR proof for a series of leaves under given indices.',
            params: [
                {
                    name: 'leafIndices',
                    type: 'Vec<MmrLeafIndex>'
                }
            ],
            type: 'Result<(Vec<MmrEncodableOpaqueLeaf>, MmrBatchProof), MmrError>'
        },
        generate_proof: {
            description: 'Generate MMR proof for a leaf under given index.',
            params: [
                {
                    name: 'leafIndex',
                    type: 'MmrLeafIndex'
                }
            ],
            type: 'Result<(MmrEncodableOpaqueLeaf, MmrProof), MmrError>'
        },
        mmr_root: {
            description: 'Return the on-chain MMR root hash.',
            params: [],
            type: 'Result<Hash, MmrError>'
        },
        verify_batch_proof: {
            description: 'Verify MMR proof against on-chain MMR for a batch of leaves.',
            params: [
                {
                    name: 'leaves',
                    type: 'Vec<MmrEncodableOpaqueLeaf>'
                },
                {
                    name: 'proof',
                    type: 'MmrBatchProof'
                }
            ],
            type: 'Result<(), MmrError>'
        },
        verify_batch_proof_stateless: {
            description: 'Verify MMR proof against given root hash or a batch of leaves.',
            params: [
                {
                    name: 'root',
                    type: 'Hash'
                },
                {
                    name: 'leaves',
                    type: 'Vec<MmrEncodableOpaqueLeaf>'
                },
                {
                    name: 'proof',
                    type: 'MmrBatchProof'
                }
            ],
            type: 'Result<(), MmrError>'
        },
        verify_proof: {
            description: 'Verify MMR proof against on-chain MMR.',
            params: [
                {
                    name: 'leaf',
                    type: 'MmrEncodableOpaqueLeaf'
                },
                {
                    name: 'proof',
                    type: 'MmrProof'
                }
            ],
            type: 'Result<(), MmrError>'
        },
        verify_proof_stateless: {
            description: 'Verify MMR proof against given root hash.',
            params: [
                {
                    name: 'root',
                    type: 'Hash'
                },
                {
                    name: 'leaf',
                    type: 'MmrEncodableOpaqueLeaf'
                },
                {
                    name: 'proof',
                    type: 'MmrProof'
                }
            ],
            type: 'Result<(), MmrError>'
        }
    };
    const runtime$g = {
        MmrApi: [
            {
                methods: MMR_V2,
                version: 2
            },
            {
                methods: MMR_V1,
                version: 1
            }
        ]
    };

    const definitions$G = {
        rpc: rpc$a,
        runtime: runtime$g,
        types: {
            MmrBatchProof: {
                leafIndices: 'Vec<MmrLeafIndex>',
                leafCount: 'MmrNodeIndex',
                items: 'Vec<Hash>'
            },
            MmrEncodableOpaqueLeaf: 'Bytes',
            MmrError: {
                _enum: ['Push', 'GetRoot', 'Commit', 'GenerateProof', 'Verify', 'LeafNotFound', ' PalletNotIncluded', 'InvalidLeafIndex']
            },
            MmrHash: 'Hash',
            MmrLeafBatchProof: {
                blockHash: 'BlockHash',
                leaves: 'Bytes',
                proof: 'Bytes'
            },
            MmrLeafIndex: 'u64',
            MmrLeafProof: {
                blockHash: 'BlockHash',
                leaf: 'Bytes',
                proof: 'Bytes'
            },
            MmrNodeIndex: 'u64',
            MmrProof: {
                leafIndex: 'MmrLeafIndex',
                leafCount: 'MmrNodeIndex',
                items: 'Vec<Hash>'
            }
        }
    };

    const runtime$f = {
        NftsApi: [
            {
                methods: {
                    attribute: {
                        description: 'An attribute',
                        params: [
                            {
                                name: 'collection',
                                type: 'NftCollectionId'
                            },
                            {
                                name: 'item',
                                type: 'NftItemId'
                            },
                            {
                                name: 'key',
                                type: 'Bytes'
                            }
                        ],
                        type: 'Option<Bytes>'
                    },
                    collection_attribute: {
                        description: 'A collection attribute',
                        params: [
                            {
                                name: 'collection',
                                type: 'NftCollectionId'
                            },
                            {
                                name: 'key',
                                type: 'Bytes'
                            }
                        ],
                        type: 'Option<Bytes>'
                    },
                    collection_owner: {
                        description: 'A collection owner',
                        params: [
                            {
                                name: 'collection',
                                type: 'NftCollectionId'
                            }
                        ],
                        type: 'Option<AccountId>'
                    },
                    custom_attribute: {
                        description: 'A custom attribute',
                        params: [
                            {
                                name: 'account',
                                type: 'AccountId'
                            },
                            {
                                name: 'collection',
                                type: 'NftCollectionId'
                            },
                            {
                                name: 'item',
                                type: 'NftItemId'
                            },
                            {
                                name: 'key',
                                type: 'Bytes'
                            }
                        ],
                        type: 'Option<Bytes>'
                    },
                    owner: {
                        description: 'Collection owner',
                        params: [
                            {
                                name: 'collection',
                                type: 'NftCollectionId'
                            },
                            {
                                name: 'item',
                                type: 'NftItemId'
                            }
                        ],
                        type: 'Option<AccountId>'
                    },
                    system_attribute: {
                        description: 'System attribute',
                        params: [
                            {
                                name: 'collection',
                                type: 'NftCollectionId'
                            },
                            {
                                name: 'item',
                                type: 'NftItemId'
                            },
                            {
                                name: 'key',
                                type: 'Bytes'
                            }
                        ],
                        type: 'Option<Bytes>'
                    }
                },
                version: 1
            }
        ]
    };

    const definitions$F = {
        rpc: {},
        runtime: runtime$f,
        types: {
            NftCollectionId: 'u32',
            NftItemId: 'u32'
        }
    };

    const runtime$e = {
        NominationPoolsApi: [
            {
                methods: {
                    balance_to_points: {
                        description: 'Returns the equivalent points of `new_funds` for a given pool.',
                        params: [
                            {
                                name: 'poolId',
                                type: 'NpPoolId'
                            },
                            {
                                name: 'newFunds',
                                type: 'Balance'
                            }
                        ],
                        type: 'Balance'
                    },
                    pending_rewards: {
                        description: 'Returns the pending rewards for the given member.',
                        params: [
                            {
                                name: 'member',
                                type: 'AccountId'
                            }
                        ],
                        type: 'Balance'
                    },
                    points_to_balance: {
                        description: 'Returns the equivalent balance of `points` for a given pool.',
                        params: [
                            {
                                name: 'poolId',
                                type: 'NpPoolId'
                            },
                            {
                                name: 'points',
                                type: 'Balance'
                            }
                        ],
                        type: 'Balance'
                    }
                },
                version: 1
            }
        ]
    };

    const definitions$E = {
        rpc: {},
        runtime: runtime$e,
        types: {
            NpApiError: {
                _enum: ['MemberNotFound', 'OverflowInPendingRewards']
            },
            NpPoolId: 'u32'
        }
    };

    const definitions$D = {
        rpc: {},
        types: {
            DeferredOffenceOf: '(Vec<OffenceDetails>, Vec<Perbill>, SessionIndex)',
            Kind: '[u8; 16]',
            OffenceDetails: {
                offender: 'Offender',
                reporters: 'Vec<Reporter>'
            },
            Offender: 'IdentificationTuple',
            OpaqueTimeSlot: 'Bytes',
            ReportIdOf: 'Hash',
            Reporter: 'AccountId'
        }
    };

    const runtime$d = {
        DifficultyApi: [
            {
                methods: {
                    difficulty: {
                        description: 'Return the target difficulty of the next block.',
                        params: [],
                        type: 'Raw'
                    }
                },
                version: 1
            }
        ],
        TimestampApi: [
            {
                methods: {
                    timestamp: {
                        description: 'API necessary for timestamp-based difficulty adjustment algorithms.',
                        params: [],
                        type: 'Moment'
                    }
                },
                version: 1
            }
        ]
    };

    const definitions$C = {
        rpc: {},
        runtime: runtime$d,
        types: {}
    };

    const definitions$B = {
        rpc: {},
        types: {
            ProxyDefinition: {
                delegate: 'AccountId',
                proxyType: 'ProxyType',
                delay: 'BlockNumber'
            },
            ProxyType: {
                _enum: ['Any', 'NonTransfer', 'Governance', 'Staking']
            },
            ProxyAnnouncement: {
                real: 'AccountId',
                callHash: 'Hash',
                height: 'BlockNumber'
            }
        }
    };

    const definitions$A = {
        rpc: {},
        types: {
            ActiveRecovery: {
                created: 'BlockNumber',
                deposit: 'Balance',
                friends: 'Vec<AccountId>'
            },
            RecoveryConfig: {
                delayPeriod: 'BlockNumber',
                deposit: 'Balance',
                friends: 'Vec<AccountId>',
                threshold: 'u16'
            }
        }
    };

    const definitions$z = {
        rpc: {},
        types: {
            Period: '(BlockNumber, u32)',
            Priority: 'u8',
            SchedulePeriod: 'Period',
            SchedulePriority: 'Priority',
            Scheduled: {
                maybeId: 'Option<Bytes>',
                priority: 'SchedulePriority',
                call: 'Call',
                maybePeriodic: 'Option<SchedulePeriod>',
                origin: 'PalletsOrigin'
            },
            ScheduledTo254: {
                maybeId: 'Option<Bytes>',
                priority: 'SchedulePriority',
                call: 'Call',
                maybePeriodic: 'Option<SchedulePeriod>'
            },
            TaskAddress: '(BlockNumber, u32)'
        }
    };

    const runtime$c = {
        SessionKeys: [
            {
                methods: {
                    decode_session_keys: {
                        description: 'Decode the given public session keys.',
                        params: [
                            {
                                name: 'encoded',
                                type: 'Bytes'
                            }
                        ],
                        type: 'Option<Vec<(Bytes, KeyTypeId)>>'
                    },
                    generate_session_keys: {
                        description: 'Generate a set of session keys with optionally using the given seed.',
                        params: [
                            {
                                name: 'seed',
                                type: 'Option<Bytes>'
                            }
                        ],
                        type: 'Bytes'
                    }
                },
                version: 1
            }
        ]
    };

    const keyTypes = {
        BeefyKey: '[u8; 33]',
        Keys: 'SessionKeys4',
        SessionKeys1: '(AccountId)',
        SessionKeys2: '(AccountId, AccountId)',
        SessionKeys3: '(AccountId, AccountId, AccountId)',
        SessionKeys4: '(AccountId, AccountId, AccountId, AccountId)',
        SessionKeys5: '(AccountId, AccountId, AccountId, AccountId, AccountId)',
        SessionKeys6: '(AccountId, AccountId, AccountId, AccountId, AccountId, AccountId)',
        SessionKeys6B: '(AccountId, AccountId, AccountId, AccountId, AccountId, BeefyKey)',
        SessionKeys7: '(AccountId, AccountId, AccountId, AccountId, AccountId, AccountId, AccountId)',
        SessionKeys7B: '(AccountId, AccountId, AccountId, AccountId, AccountId, AccountId, BeefyKey)',
        SessionKeys8: '(AccountId, AccountId, AccountId, AccountId, AccountId, AccountId, AccountId, AccountId)',
        SessionKeys8B: '(AccountId, AccountId, AccountId, AccountId, AccountId, AccountId, AccountId, BeefyKey)',
        SessionKeys9: '(AccountId, AccountId, AccountId, AccountId, AccountId, AccountId, AccountId, AccountId, AccountId)',
        SessionKeys9B: '(AccountId, AccountId, AccountId, AccountId, AccountId, AccountId, AccountId, AccountId, BeefyKey)',
        SessionKeys10: '(AccountId, AccountId, AccountId, AccountId, AccountId, AccountId, AccountId, AccountId, AccountId, AccountId)',
        SessionKeys10B: '(AccountId, AccountId, AccountId, AccountId, AccountId, AccountId, AccountId, AccountId, AccountId, BeefyKey)'
    };
    const definitions$y = {
        rpc: {},
        runtime: runtime$c,
        types: {
            ...keyTypes,
            FullIdentification: 'Exposure',
            IdentificationTuple: '(ValidatorId, FullIdentification)',
            MembershipProof: {
                session: 'SessionIndex',
                trieNodes: 'Vec<Bytes>',
                validatorCount: 'ValidatorCount'
            },
            SessionIndex: 'u32',
            ValidatorCount: 'u32'
        }
    };

    const definitions$x = {
        rpc: {},
        types: {
            Bid: {
                who: 'AccountId',
                kind: 'BidKind',
                value: 'Balance'
            },
            BidKind: {
                _enum: {
                    Deposit: 'Balance',
                    Vouch: '(AccountId, Balance)'
                }
            },
            SocietyJudgement: {
                _enum: ['Rebid', 'Reject', 'Approve']
            },
            SocietyVote: {
                _enum: ['Skeptic', 'Reject', 'Approve']
            },
            StrikeCount: 'u32',
            VouchingStatus: {
                _enum: ['Vouching', 'Banned']
            }
        }
    };

    const runtime$b = {
        StakingApi: [
            {
                methods: {
                    nominations_quota: {
                        description: 'Returns the nominations quota for a nominator with a given balance.',
                        params: [
                            {
                                name: 'balance',
                                type: 'Balance'
                            }
                        ],
                        type: 'u32'
                    }
                },
                version: 1
            }
        ]
    };

    const deprecated = {
        Points: 'u32',
        EraPoints: {
            total: 'Points',
            individual: 'Vec<Points>'
        }
    };
    const phragmen = {
        CompactAssignments: 'CompactAssignmentsWith16',
        CompactAssignmentsWith16: {
            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)>'
        },
        CompactAssignmentsWith24: {
            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)>',
            votes17: 'Vec<(NominatorIndexCompact, [CompactScoreCompact; 16], ValidatorIndexCompact)>',
            votes18: 'Vec<(NominatorIndexCompact, [CompactScoreCompact; 17], ValidatorIndexCompact)>',
            votes19: 'Vec<(NominatorIndexCompact, [CompactScoreCompact; 18], ValidatorIndexCompact)>',
            votes20: 'Vec<(NominatorIndexCompact, [CompactScoreCompact; 19], ValidatorIndexCompact)>',
            votes21: 'Vec<(NominatorIndexCompact, [CompactScoreCompact; 20], ValidatorIndexCompact)>',
            votes22: 'Vec<(NominatorIndexCompact, [CompactScoreCompact; 21], ValidatorIndexCompact)>',
            votes23: 'Vec<(NominatorIndexCompact, [CompactScoreCompact; 22], ValidatorIndexCompact)>',
            votes24: 'Vec<(NominatorIndexCompact, [CompactScoreCompact; 23], ValidatorIndexCompact)>'
        },
        CompactAssignmentsTo265: 'CompactAssignmentsWith16',
        CompactAssignmentsTo257: {
            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)>'
        },
        CompactScore: '(ValidatorIndex, OffchainAccuracy)',
        CompactScoreCompact: '(ValidatorIndexCompact, OffchainAccuracyCompact)',
        ElectionCompute: {
            _enum: ['OnChain', 'Signed', 'Unsigned']
        },
        ElectionPhase: {
            _enum: {
                Off: null,
                Signed: null,
                Unsigned: '(bool, BlockNumber)',
                Emergency: null
            }
        },
        ElectionResult: {
            compute: 'ElectionCompute',
            slotStake: 'Balance',
            electedStashes: 'Vec<AccountId>',
            exposures: 'Vec<(AccountId, Exposure)>'
        },
        ElectionScore: '[u128; 3]',
        ElectionSize: {
            validators: 'Compact<ValidatorIndex>',
            nominators: 'Compact<NominatorIndex>'
        },
        ElectionStatus: {
            _enum: {
                Close: 'Null',
                Open: 'BlockNumber'
            }
        },
        ExtendedBalance: 'u128',
        RawSolution: 'RawSolutionWith16',
        RawSolutionWith16: {
            compact: 'CompactAssignmentsWith16',
            score: 'ElectionScore',
            round: 'u32'
        },
        RawSolutionWith24: {
            compact: 'CompactAssignmentsWith24',
            score: 'ElectionScore',
            round: 'u32'
        },
        RawSolutionTo265: 'RawSolutionWith16',
        ReadySolution: {
            supports: 'SolutionSupports',
            score: 'ElectionScore',
            compute: 'ElectionCompute'
        },
        RoundSnapshot: {
            voters: 'Vec<(AccountId, VoteWeight, Vec<AccountId>)>',
            targets: 'Vec<AccountId>'
        },
        SeatHolder: {
            who: 'AccountId',
            stake: 'Balance',
            deposit: 'Balance'
        },
        SignedSubmission: {
            _fallback: 'SignedSubmissionTo276',
            who: 'AccountId',
            deposit: 'Balance',
            solution: 'RawSolution',
            reward: 'Balance'
        },
        SignedSubmissionTo276: {
            who: 'AccountId',
            deposit: 'Balance',
            solution: 'RawSolution'
        },
        SignedSubmissionOf: 'SignedSubmission',
        SolutionOrSnapshotSize: {
            voters: 'Compact<u32>',
            targets: 'Compact<u32>'
        },
        SolutionSupport: {
            total: 'ExtendedBalance',
            voters: 'Vec<(AccountId, ExtendedBalance)>'
        },
        SolutionSupports: 'Vec<(AccountId, SolutionSupport)>',
        Supports: 'SolutionSupports',
        SubmissionIndicesOf: 'BTreeMap<ElectionScore, u32>',
        Voter: {
            votes: 'Vec<AccountId>',
            stake: 'Balance',
            deposit: 'Balance'
        },
        VoteWeight: 'u64'
    };
    const definitions$w = {
        rpc: {},
        runtime: runtime$b,
        types: {
            ...deprecated,
            ...phragmen,
            ActiveEraInfo: {
                index: 'EraIndex',
                start: 'Option<Moment>'
            },
            EraIndex: 'u32',
            EraRewardPoints: {
                total: 'RewardPoint',
                individual: 'BTreeMap<AccountId, RewardPoint>'
            },
            EraRewards: {
                total: 'u32',
                rewards: 'Vec<u32>'
            },
            Exposure: {
                total: 'Compact<Balance>',
                own: 'Compact<Balance>',
                others: 'Vec<IndividualExposure>'
            },
            Forcing: {
                _enum: [
                    'NotForcing',
                    'ForceNew',
                    'ForceNone',
                    'ForceAlways'
                ]
            },
            IndividualExposure: {
                who: 'AccountId',
                value: 'Compact<Balance>'
            },
            KeyType: 'AccountId',
            MomentOf: 'Moment',
            Nominations: {
                targets: 'Vec<AccountId>',
                submittedIn: 'EraIndex',
                suppressed: 'bool'
            },
            NominatorIndex: 'u32',
            NominatorIndexCompact: 'Compact<NominatorIndex>',
            OffchainAccuracy: 'PerU16',
            OffchainAccuracyCompact: 'Compact<OffchainAccuracy>',
            PhragmenScore: '[u128; 3]',
            Points: 'u32',
            RewardDestination: {
                _enum: {
                    Staked: 'Null',
                    Stash: 'Null',
                    Controller: 'Null',
                    Account: 'AccountId',
                    None: 'Null'
                }
            },
            RewardPoint: 'u32',
            SlashJournalEntry: {
                who: 'AccountId',
                amount: 'Balance',
                ownSlash: 'Balance'
            },
            SlashingSpansTo204: {
                spanIndex: 'SpanIndex',
                lastStart: 'EraIndex',
                prior: 'Vec<EraIndex>'
            },
            SlashingSpans: {
                spanIndex: 'SpanIndex',
                lastStart: 'EraIndex',
                lastNonzeroSlash: 'EraIndex',
                prior: 'Vec<EraIndex>'
            },
            SpanIndex: 'u32',
            SpanRecord: {
                slashed: 'Balance',
                paidOut: 'Balance'
            },
            StakingLedgerTo223: {
                stash: 'AccountId',
                total: 'Compact<Balance>',
                active: 'Compact<Balance>',
                unlocking: 'Vec<UnlockChunk>'
            },
            StakingLedgerTo240: {
                _fallback: 'StakingLedgerTo223',
                stash: 'AccountId',
                total: 'Compact<Balance>',
                active: 'Compact<Balance>',
                unlocking: 'Vec<UnlockChunk>',
                lastReward: 'Option<EraIndex>'
            },
            StakingLedger: {
                stash: 'AccountId',
                total: 'Compact<Balance>',
                active: 'Compact<Balance>',
                unlocking: 'Vec<UnlockChunk>',
                claimedRewards: 'Vec<EraIndex>'
            },
            UnappliedSlashOther: '(AccountId, Balance)',
            UnappliedSlash: {
                validator: 'AccountId',
                own: 'Balance',
                others: 'Vec<UnappliedSlashOther>',
                reporters: 'Vec<AccountId>',
                payout: 'Balance'
            },
            UnlockChunk: {
                value: 'Compact<Balance>',
                era: 'Compact<BlockNumber>'
            },
            ValidatorIndex: 'u16',
            ValidatorIndexCompact: 'Compact<ValidatorIndex>',
            ValidatorPrefs: 'ValidatorPrefsWithBlocked',
            ValidatorPrefsWithCommission: {
                commission: 'Compact<Perbill>'
            },
            ValidatorPrefsWithBlocked: {
                commission: 'Compact<Perbill>',
                blocked: 'bool'
            },
            ValidatorPrefsTo196: {
                validatorPayment: 'Compact<Balance>'
            },
            ValidatorPrefsTo145: {
                unstakeThreshold: 'Compact<u32>',
                validatorPayment: 'Compact<Balance>'
            }
        }
    };

    const definitions$v = {
        rpc: {},
        types: {
            WeightToFeeCoefficient: {
                coeffInteger: 'Balance',
                coeffFrac: 'Perbill',
                negative: 'bool',
                degree: 'u8'
            }
        }
    };

    const rpc$9 = {
        genSyncSpec: {
            description: 'Returns the json-serialized chainspec running the node, with a sync state.',
            endpoint: 'sync_state_genSyncSpec',
            params: [
                {
                    name: 'raw',
                    type: 'bool'
                }
            ],
            type: 'Json'
        }
    };

    const definitions$u = {
        rpc: rpc$9,
        types: {}
    };

    const rpc$8 = {
        accountNextIndex: {
            alias: ['account_nextIndex'],
            description: 'Retrieves the next accountIndex as available on the node',
            params: [
                {
                    name: 'accountId',
                    type: 'AccountId'
                }
            ],
            type: 'Index'
        },
        addLogFilter: {
            description: 'Adds the supplied directives to the current log filter',
            isUnsafe: true,
            params: [
                {
                    name: 'directives',
                    type: 'Text'
                }
            ],
            type: 'Null'
        },
        addReservedPeer: {
            description: 'Adds a reserved peer',
            isUnsafe: true,
            params: [
                {
                    name: 'peer',
                    type: 'Text'
                }
            ],
            type: 'Text'
        },
        chain: {
            description: 'Retrieves the chain',
            params: [],
            type: 'Text'
        },
        chainType: {
            description: 'Retrieves the chain type',
            params: [],
            type: 'ChainType'
        },
        dryRun: {
            alias: ['system_dryRunAt'],
            description: 'Dry run an extrinsic at a given block',
            isUnsafe: true,
            params: [
                {
                    name: 'extrinsic',
                    type: 'Bytes'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'ApplyExtrinsicResult'
        },
        health: {
            description: 'Return health status of the node',
            noErrorLog: true,
            params: [],
            type: 'Health'
        },
        localListenAddresses: {
            description: 'The addresses include a trailing /p2p/ with the local PeerId, and are thus suitable to be passed to addReservedPeer or as a bootnode address for example',
            params: [],
            type: 'Vec<Text>'
        },
        localPeerId: {
            description: 'Returns the base58-encoded PeerId of the node',
            params: [],
            type: 'Text'
        },
        name: {
            description: 'Retrieves the node name',
            params: [],
            type: 'Text'
        },
        networkState: {
            alias: ['system_unstable_networkState'],
            description: 'Returns current state of the network',
            isUnsafe: true,
            params: [],
            type: 'NetworkState'
        },
        nodeRoles: {
            description: 'Returns the roles the node is running as',
            params: [],
            type: 'Vec<NodeRole>'
        },
        peers: {
            description: 'Returns the currently connected peers',
            isUnsafe: true,
            params: [],
            type: 'Vec<PeerInfo>'
        },
        properties: {
            description: 'Get a custom set of properties as a JSON object, defined in the chain spec',
            params: [],
            type: 'ChainProperties'
        },
        removeReservedPeer: {
            description: 'Remove a reserved peer',
            isUnsafe: true,
            params: [
                {
                    name: 'peerId',
                    type: 'Text'
                }
            ],
            type: 'Text'
        },
        reservedPeers: {
            description: 'Returns the list of reserved peers',
            params: [],
            type: 'Vec<Text>'
        },
        resetLogFilter: {
            description: 'Resets the log filter to Substrate defaults',
            isUnsafe: true,
            params: [],
            type: 'Null'
        },
        syncState: {
            description: 'Returns the state of the syncing of the node',
            params: [],
            type: 'SyncState'
        },
        version: {
            description: 'Retrieves the version of the node',
            params: [],
            type: 'Text'
        }
    };

    const runtime$a = {
        AccountNonceApi: [
            {
                methods: {
                    account_nonce: {
                        description: 'The API to query account nonce (aka transaction index)',
                        params: [
                            {
                                name: 'accountId',
                                type: 'AccountId'
                            }
                        ],
                        type: 'Index'
                    }
                },
                version: 1
            }
        ]
    };

    const definitions$t = {
        rpc: rpc$8,
        runtime: runtime$a,
        types: {
            AccountInfo: 'AccountInfoWithTripleRefCount',
            AccountInfoWithRefCountU8: {
                nonce: 'Index',
                refcount: 'u8',
                data: 'AccountData'
            },
            AccountInfoWithRefCount: {
                _fallback: 'AccountInfoWithRefCountU8',
                nonce: 'Index',
                refcount: 'RefCount',
                data: 'AccountData'
            },
            AccountInfoWithDualRefCount: {
                _fallback: 'AccountInfoWithRefCount',
                nonce: 'Index',
                consumers: 'RefCount',
                providers: 'RefCount',
                data: 'AccountData'
            },
            AccountInfoWithProviders: 'AccountInfoWithDualRefCount',
            AccountInfoWithTripleRefCount: {
                _fallback: 'AccountInfoWithDualRefCount',
                nonce: 'Index',
                consumers: 'RefCount',
                providers: 'RefCount',
                sufficients: 'RefCount',
                data: 'AccountData'
            },
            ApplyExtrinsicResult: 'Result<DispatchOutcome, TransactionValidityError>',
            ApplyExtrinsicResultPre6: 'Result<DispatchOutcomePre6, TransactionValidityError>',
            ArithmeticError: {
                _enum: [
                    'Underflow',
                    'Overflow',
                    'DivisionByZero'
                ]
            },
            BlockLength: {
                max: 'PerDispatchClassU32'
            },
            BlockWeights: {
                baseBlock: 'Weight',
                maxBlock: 'Weight',
                perClass: 'PerDispatchClassWeightsPerClass'
            },
            ChainProperties: 'GenericChainProperties',
            ChainType: {
                _enum: {
                    Development: 'Null',
                    Local: 'Null',
                    Live: 'Null',
                    Custom: 'Text'
                }
            },
            ConsumedWeight: 'PerDispatchClassWeight',
            DigestOf: 'Digest',
            DispatchClass: {
                _enum: ['Normal', 'Operational', 'Mandatory']
            },
            DispatchError: {
                _enum: {
                    Other: 'Null',
                    CannotLookup: 'Null',
                    BadOrigin: 'Null',
                    Module: 'DispatchErrorModule',
                    ConsumerRemaining: 'Null',
                    NoProviders: 'Null',
                    TooManyConsumers: 'Null',
                    Token: 'TokenError',
                    Arithmetic: 'ArithmeticError',
                    Transactional: 'TransactionalError',
                    Exhausted: 'Null',
                    Corruption: 'Null',
                    Unavailable: 'Null'
                }
            },
            DispatchErrorPre6: {
                _enum: {
                    Other: 'Null',
                    CannotLookup: 'Null',
                    BadOrigin: 'Null',
                    Module: 'DispatchErrorModulePre6',
                    ConsumerRemaining: 'Null',
                    NoProviders: 'Null',
                    TooManyConsumers: 'Null',
                    Token: 'TokenError',
                    Arithmetic: 'ArithmeticError',
                    Transactional: 'TransactionalError'
                }
            },
            DispatchErrorPre6First: {
                _enum: {
                    Other: 'Null',
                    CannotLookup: 'Null',
                    BadOrigin: 'Null',
                    Module: 'DispatchErrorModulePre6',
                    ConsumerRemaining: 'Null',
                    NoProviders: 'Null',
                    Token: 'TokenError',
                    Arithmetic: 'ArithmeticError',
                    Transactional: 'TransactionalError'
                }
            },
            DispatchErrorModuleU8: {
                index: 'u8',
                error: 'u8'
            },
            DispatchErrorModuleU8a: {
                index: 'u8',
                error: '[u8; 4]'
            },
            DispatchErrorModule: 'DispatchErrorModuleU8a',
            DispatchErrorModulePre6: 'DispatchErrorModuleU8',
            DispatchErrorTo198: {
                module: 'Option<u8>',
                error: 'u8'
            },
            DispatchInfo: {
                weight: 'Weight',
                class: 'DispatchClass',
                paysFee: 'Pays'
            },
            DispatchInfoTo190: {
                weight: 'Weight',
                class: 'DispatchClass'
            },
            DispatchInfoTo244: {
                weight: 'Weight',
                class: 'DispatchClass',
                paysFee: 'bool'
            },
            DispatchOutcome: 'Result<(), DispatchError>',
            DispatchOutcomePre6: 'Result<(), DispatchErrorPre6>',
            DispatchResult: 'Result<(), DispatchError>',
            DispatchResultOf: 'DispatchResult',
            DispatchResultTo198: 'Result<(), Text>',
            Event: 'GenericEvent',
            EventId: '[u8; 2]',
            EventIndex: 'u32',
            EventRecord: {
                phase: 'Phase',
                event: 'Event',
                topics: 'Vec<Hash>'
            },
            Health: {
                peers: 'u64',
                isSyncing: 'bool',
                shouldHavePeers: 'bool'
            },
            InvalidTransaction: {
                _enum: {
                    Call: 'Null',
                    Payment: 'Null',
                    Future: 'Null',
                    Stale: 'Null',
                    BadProof: 'Null',
                    AncientBirthBlock: 'Null',
                    ExhaustsResources: 'Null',
                    Custom: 'u8',
                    BadMandatory: 'Null',
                    MandatoryDispatch: 'Null',
                    BadSigner: 'Null'
                }
            },
            Key: 'Bytes',
            LastRuntimeUpgradeInfo: {
                specVersion: 'Compact<u32>',
                specName: 'Text'
            },
            NetworkState: {
                peerId: 'Text',
                listenedAddresses: 'Vec<Text>',
                externalAddresses: 'Vec<Text>',
                connectedPeers: 'HashMap<Text, Peer>',
                notConnectedPeers: 'HashMap<Text, NotConnectedPeer>',
                averageDownloadPerSec: 'u64',
                averageUploadPerSec: 'u64',
                peerset: 'NetworkStatePeerset'
            },
            NetworkStatePeerset: {
                messageQueue: 'u64',
                nodes: 'HashMap<Text, NetworkStatePeersetInfo>'
            },
            NetworkStatePeersetInfo: {
                connected: 'bool',
                reputation: 'i32'
            },
            NodeRole: {
                _enum: {
                    Full: 'Null',
                    LightClient: 'Null',
                    Authority: 'Null',
                    UnknownRole: 'u8'
                }
            },
            NotConnectedPeer: {
                knownAddresses: 'Vec<Text>',
                latestPingTime: 'Option<PeerPing>',
                versionString: 'Option<Text>'
            },
            Peer: {
                enabled: 'bool',
                endpoint: 'PeerEndpoint',
                knownAddresses: 'Vec<Text>',
                latestPingTime: 'PeerPing',
                open: 'bool',
                versionString: 'Text'
            },
            PeerEndpoint: {
                listening: 'PeerEndpointAddr'
            },
            PeerEndpointAddr: {
                _alias: {
                    localAddr: 'local_addr',
                    sendBackAddr: 'send_back_addr'
                },
                localAddr: 'Text',
                sendBackAddr: 'Text'
            },
            PeerPing: {
                nanos: 'u64',
                secs: 'u64'
            },
            PeerInfo: {
                peerId: 'Text',
                roles: 'Text',
                protocolVersion: 'u32',
                bestHash: 'Hash',
                bestNumber: 'BlockNumber'
            },
            PerDispatchClassU32: {
                normal: 'u32',
                operational: 'u32',
                mandatory: 'u32'
            },
            PerDispatchClassWeight: {
                normal: 'Weight',
                operational: 'Weight',
                mandatory: 'Weight'
            },
            PerDispatchClassWeightsPerClass: {
                normal: 'WeightPerClass',
                operational: 'WeightPerClass',
                mandatory: 'WeightPerClass'
            },
            Phase: {
                _enum: {
                    ApplyExtrinsic: 'u32',
                    Finalization: 'Null',
                    Initialization: 'Null'
                }
            },
            RawOrigin: {
                _enum: {
                    Root: 'Null',
                    Signed: 'AccountId',
                    None: 'Null'
                }
            },
            RefCount: 'u32',
            RefCountTo259: 'u8',
            SyncState: {
                startingBlock: 'BlockNumber',
                currentBlock: 'BlockNumber',
                highestBlock: 'Option<BlockNumber>'
            },
            SystemOrigin: 'RawOrigin',
            TokenError: {
                _enum: [
                    'NoFunds',
                    'WouldDie',
                    'BelowMinimum',
                    'CannotCreate',
                    'UnknownAsset',
                    'Frozen',
                    'Unsupported',
                    'Underflow',
                    'Overflow'
                ]
            },
            TransactionValidityError: {
                _enum: {
                    Invalid: 'InvalidTransaction',
                    Unknown: 'UnknownTransaction'
                }
            },
            TransactionalError: {
                _enum: [
                    'LimitReached',
                    'NoLayer'
                ]
            },
            UnknownTransaction: {
                _enum: {
                    CannotLookup: 'Null',
                    NoUnsignedValidator: 'Null',
                    Custom: 'u8'
                }
            },
            WeightPerClass: {
                baseExtrinsic: 'Weight',
                maxExtrinsic: 'Option<Weight>',
                maxTotal: 'Option<Weight>',
                reserved: 'Option<Weight>'
            }
        }
    };

    const definitions$s = {
        rpc: {},
        types: {
            Bounty: {
                proposer: 'AccountId',
                value: 'Balance',
                fee: 'Balance',
                curatorDeposit: 'Balance',
                bond: 'Balance',
                status: 'BountyStatus'
            },
            BountyIndex: 'u32',
            BountyStatus: {
                _enum: {
                    Proposed: 'Null',
                    Approved: 'Null',
                    Funded: 'Null',
                    CuratorProposed: 'BountyStatusCuratorProposed',
                    Active: 'BountyStatusActive',
                    PendingPayout: 'BountyStatusPendingPayout'
                }
            },
            BountyStatusActive: {
                curator: 'AccountId',
                updateDue: 'BlockNumber'
            },
            BountyStatusCuratorProposed: {
                curator: 'AccountId'
            },
            BountyStatusPendingPayout: {
                curator: 'AccountId',
                beneficiary: 'AccountId',
                unlockAt: 'BlockNumber'
            },
            OpenTip: {
                reason: 'Hash',
                who: 'AccountId',
                finder: 'AccountId',
                deposit: 'Balance',
                closes: 'Option<BlockNumber>',
                tips: 'Vec<OpenTipTip>',
                findersFee: 'bool'
            },
            OpenTipTo225: {
                reason: 'Hash',
                who: 'AccountId',
                finder: 'Option<OpenTipFinderTo225>',
                closes: 'Option<BlockNumber>',
                tips: 'Vec<OpenTipTip>'
            },
            OpenTipFinderTo225: '(AccountId, Balance)',
            OpenTipTip: '(AccountId, Balance)',
            TreasuryProposal: {
                proposer: 'AccountId',
                value: 'Balance',
                beneficiary: 'AccountId',
                bond: 'Balance'
            }
        }
    };

    const definitions$r = {
        rpc: {},
        types: {
            Multiplier: 'Fixed128'
        }
    };

    const runtime$9 = {
        TaggedTransactionQueue: [
            {
                methods: {
                    validate_transaction: {
                        description: 'Validate the transaction.',
                        params: [
                            {
                                name: 'source',
                                type: 'TransactionSource'
                            },
                            {
                                name: 'tx',
                                type: 'Extrinsic'
                            },
                            {
                                name: 'blockHash',
                                type: 'BlockHash'
                            }
                        ],
                        type: 'TransactionValidity'
                    }
                },
                version: 3
            },
            {
                methods: {
                    validate_transaction: {
                        description: 'Validate the transaction.',
                        params: [
                            {
                                name: 'source',
                                type: 'TransactionSource'
                            },
                            {
                                name: 'tx',
                                type: 'Extrinsic'
                            }
                        ],
                        type: 'TransactionValidity'
                    }
                },
                version: 2
            },
            {
                methods: {
                    validate_transaction: {
                        description: 'Validate the transaction.',
                        params: [
                            {
                                name: 'tx',
                                type: 'Extrinsic'
                            }
                        ],
                        type: 'TransactionValidity'
                    }
                },
                version: 1
            }
        ]
    };

    const definitions$q = {
        rpc: {},
        runtime: runtime$9,
        types: {
            TransactionSource: {
                _enum: ['InBlock', 'Local', 'External']
            },
            TransactionValidity: 'Result<ValidTransaction, TransactionValidityError>',
            ValidTransaction: {
                priority: 'TransactionPriority',
                requires: 'Vec<TransactionTag>',
                provides: 'Vec<TransactionTag>',
                longevity: 'TransactionLongevity',
                propagate: 'bool'
            }
        }
    };

    const definitions$p = {
        rpc: {},
        types: {
            ClassId: 'u32',
            InstanceId: 'u32',
            DepositBalance: 'Balance',
            DepositBalanceOf: 'Balance',
            ClassDetails: {
                owner: 'AccountId',
                issuer: 'AccountId',
                admin: 'AccountId',
                freezer: 'AccountId',
                totalDeposit: 'DepositBalance',
                freeHolding: 'bool',
                instances: 'u32',
                instanceMetadatas: 'u32',
                attributes: 'u32',
                isFrozen: 'bool'
            },
            DestroyWitness: {
                instances: 'Compact<u32>',
                instanceMetadatas: 'Compact<u32>',
                attributes: 'Compact<u32>'
            },
            InstanceDetails: {
                owner: 'AccountId',
                approved: 'Option<AccountId>',
                isFrozen: 'bool',
                deposit: 'DepositBalance'
            },
            ClassMetadata: {
                deposit: 'DepositBalance',
                data: 'Vec<u8>',
                isFrozen: 'bool'
            },
            InstanceMetadata: {
                deposit: 'DepositBalance',
                data: 'Vec<u8>',
                isFrozen: 'bool'
            }
        }
    };

    const definitions$o = {
        rpc: {},
        types: {
            Multisig: {
                when: 'Timepoint',
                deposit: 'Balance',
                depositor: 'AccountId',
                approvals: 'Vec<AccountId>'
            },
            Timepoint: {
                height: 'BlockNumber',
                index: 'u32'
            }
        }
    };

    const definitions$n = {
        rpc: {},
        types: {
            VestingInfo: {
                locked: 'Balance',
                perBlock: 'Balance',
                startingBlock: 'BlockNumber'
            }
        }
    };

    const definitions$m = {
        rpc: {},
        types: {
            BlockAttestations: {
                receipt: 'CandidateReceipt',
                valid: 'Vec<AccountId>',
                invalid: 'Vec<AccountId>'
            },
            IncludedBlocks: {
                actualNumber: 'BlockNumber',
                session: 'SessionIndex',
                randomSeed: 'H256',
                activeParachains: 'Vec<ParaId>',
                paraBlocks: 'Vec<Hash>'
            },
            MoreAttestations: {}
        }
    };

    const definitions$l = {
        rpc: {},
        types: {
            BridgedBlockHash: 'H256',
            BridgedBlockNumber: 'BlockNumber',
            BridgedHeader: 'Header',
            BridgeMessageId: '(LaneId, MessageNonce)',
            CallOrigin: {
                _enum: {
                    SourceRoot: 'Null',
                    TargetAccount: '(AccountId, MultiSigner, MultiSignature)',
                    SourceAccount: 'AccountId'
                }
            },
            ChainId: '[u8; 4]',
            DeliveredMessages: {
                begin: 'MessageNonce',
                end: 'MessageNonce',
                dispatchResults: 'BitVec'
            },
            DispatchFeePayment: {
                _enum: ['AtSourceChain', 'AtTargetChain']
            },
            InboundLaneData: {
                relayers: 'Vec<UnrewardedRelayer>',
                lastConfirmedNonce: 'MessageNonce'
            },
            InboundRelayer: 'AccountId',
            InitializationData: {
                header: 'Header',
                authorityList: 'AuthorityList',
                setId: 'SetId',
                isHalted: 'bool'
            },
            LaneId: '[u8; 4]',
            MessageData: {
                payload: 'Bytes',
                fee: 'Balance'
            },
            MessagesDeliveryProofOf: {
                bridgedHeaderHash: 'BlockHash',
                storageProof: 'Vec<Bytes>',
                lane: 'LaneId'
            },
            MessageKey: {
                laneId: 'LaneId',
                nonce: 'MessageNonce'
            },
            MessageNonce: 'u64',
            MessagesProofOf: {
                bridgedHeaderHash: 'BridgedBlockHash',
                storageProof: 'Vec<Bytes>',
                lane: 'LaneId',
                noncesStart: 'MessageNonce',
                noncesEnd: 'MessageNonce'
            },
            OperatingMode: {
                _enum: ['Normal', 'RejectingOutboundMessages', 'Halted']
            },
            OutboundLaneData: {
                oldestUnprunedNonce: 'MessageNonce',
                latestReceivedNonce: 'MessageNonce',
                latestGeneratedNonce: 'MessageNonce'
            },
            OutboundMessageFee: 'Balance',
            OutboundPayload: {
                specVersion: 'u32',
                weight: 'Weight',
                origin: 'CallOrigin',
                dispatchFeePayment: 'DispatchFeePayment',
                call: 'Bytes'
            },
            Parameter: 'Null',
            RelayerId: 'AccountId',
            UnrewardedRelayer: {
                relayer: 'RelayerId',
                messages: 'DeliveredMessages'
            },
            UnrewardedRelayersState: {
                unrewardedRelayer_Entries: 'MessageNonce',
                messagesInOldestEntry: 'MessageNonce',
                totalMessages: 'MessageNonce'
            }
        }
    };

    const definitions$k = {
        rpc: {},
        types: {
            StatementKind: {
                _enum: ['Regular', 'Saft']
            }
        }
    };

    const definitions$j = {
        rpc: {},
        types: {
            FundIndex: 'u32',
            LastContribution: {
                _enum: {
                    Never: 'Null',
                    PreEnding: 'u32',
                    Ending: 'BlockNumber'
                }
            },
            FundInfo: {
                depositor: 'AccountId',
                verifier: 'Option<MultiSigner>',
                deposit: 'Balance',
                raised: 'Balance',
                end: 'BlockNumber',
                cap: 'Balance',
                lastContribution: 'LastContribution',
                firstPeriod: 'LeasePeriod',
                lastPeriod: 'LeasePeriod',
                trieIndex: 'TrieIndex'
            },
            TrieIndex: 'u32'
        }
    };

    const runtime$8 = {
        CollectCollationInfo: [
            {
                methods: {
                    collect_collation_info: {
                        description: 'Collect information about a collation.',
                        params: [
                            {
                                name: 'header',
                                type: 'Header'
                            }
                        ],
                        type: 'CollationInfo'
                    }
                },
                version: 2
            },
            {
                methods: {
                    collect_collation_info: {
                        description: 'Collect information about a collation.',
                        params: [],
                        type: 'CollationInfoV1'
                    }
                },
                version: 1
            }
        ]
    };

    const dmpQueue = {
        CollationInfo: {
            upwardMessages: 'Vec<UpwardMessage>',
            horizontalMessages: 'Vec<OutboundHrmpMessage>',
            newValidationCode: 'Option<ValidationCode>',
            processedDownwardMessages: 'u32',
            hrmpWatermark: 'RelayBlockNumber',
            headData: 'HeadData'
        },
        CollationInfoV1: {
            upwardMessages: 'Vec<UpwardMessage>',
            horizontalMessages: 'Vec<OutboundHrmpMessage>',
            newValidationCode: 'Option<ValidationCode>',
            processedDownwardMessages: 'u32',
            hrmpWatermark: 'RelayBlockNumber'
        },
        ConfigData: {
            maxIndividual: 'Weight'
        },
        MessageId: '[u8; 32]',
        OverweightIndex: 'u64',
        PageCounter: 'u32',
        PageIndexData: {
            beginUsed: 'PageCounter',
            endUsed: 'PageCounter',
            overweightCount: 'OverweightIndex'
        }
    };
    const definitions$i = {
        rpc: {},
        runtime: runtime$8,
        types: dmpQueue
    };

    const finalityV1 = {
        methods: {
            best_finalized: {
                description: 'Returns number and hash of the best finalized header known to the bridge module.',
                params: [],
                type: '(BlockNumber, Hash)'
            }
        },
        version: 1
    };
    const runtime$7 = {
        KusamaFinalityApi: [finalityV1],
        PolkadotFinalityApi: [finalityV1],
        RococoFinalityApi: [finalityV1],
        WestendFinalityApi: [finalityV1]
    };

    const definitions$h = {
        rpc: {},
        runtime: runtime$7,
        types: {}
    };

    const hrmpTypes = {
        HrmpChannel: {
            maxCapacity: 'u32',
            maxTotalSize: 'u32',
            maxMessageSize: 'u32',
            msgCount: 'u32',
            totalSize: 'u32',
            mqcHead: 'Option<Hash>',
            senderDeposit: 'Balance',
            recipientDeposit: 'Balance'
        },
        HrmpChannelId: {
            sender: 'u32',
            receiver: 'u32'
        },
        HrmpOpenChannelRequest: {
            confirmed: 'bool',
            age: 'SessionIndex',
            senderDeposit: 'Balance',
            maxMessageSize: 'u32',
            maxCapacity: 'u32',
            maxTotalSize: 'u32'
        }
    };

    const PH_V1_TO_V2 = {
        assumed_validation_data: {
            description: 'Returns the persisted validation data for the given `ParaId` along with the corresponding validation code hash.',
            params: [
                {
                    name: 'paraId',
                    type: 'ParaId'
                },
                {
                    name: 'hash',
                    type: 'Hash'
                }
            ],
            type: 'Option<(PersistedValidationData, ValidationCodeHash)>'
        },
        availability_cores: {
            description: 'Yields information on all availability cores as relevant to the child block.',
            params: [],
            type: 'Vec<CoreState>'
        },
        candidate_events: {
            description: 'Get a vector of events concerning candidates that occurred within a block.',
            params: [],
            type: 'Vec<CandidateEvent>'
        },
        candidate_pending_availability: {
            description: 'Get the receipt of a candidate pending availability.',
            params: [
                {
                    name: 'paraId',
                    type: 'ParaId'
                }
            ],
            type: 'Option<CommittedCandidateReceipt>'
        },
        check_validation_outputs: {
            description: 'Checks if the given validation outputs pass the acceptance criteria.',
            params: [
                {
                    name: 'paraId',
                    type: 'ParaId'
                },
                {
                    name: 'outputs',
                    type: 'CandidateCommitments'
                }
            ],
            type: 'bool'
        },
        dmq_contents: {
            description: 'Get all the pending inbound messages in the downward message queue for a para.',
            params: [
                {
                    name: 'paraId',
                    type: 'ParaId'
                }
            ],
            type: 'Vec<InboundDownwardMessage>'
        },
        inbound_hrmp_channels_contents: {
            description: 'Get the contents of all channels addressed to the given recipient.',
            params: [
                {
                    name: 'paraId',
                    type: 'ParaId'
                }
            ],
            type: 'Vec<InboundHrmpMessage>'
        },
        on_chain_votes: {
            description: 'Scrape dispute relevant from on-chain, backing votes and resolved disputes.',
            params: [],
            type: 'Option<ScrapedOnChainVotes>'
        },
        persisted_validation_data: {
            description: 'Yields the persisted validation data for the given `ParaId` along with an assumption that should be used if the para currently occupies a core.',
            params: [
                {
                    name: 'paraId',
                    type: 'ParaId'
                },
                {
                    name: 'assumption',
                    type: 'OccupiedCoreAssumption'
                }
            ],
            type: 'Option<PersistedValidationData>'
        },
        session_index_for_child: {
            description: 'Returns the session index expected at a child of the block.',
            params: [],
            type: 'SessionIndex'
        },
        validation_code: {
            description: 'Fetch the validation code used by a para, making the given `OccupiedCoreAssumption`.',
            params: [
                {
                    name: 'paraId',
                    type: 'ParaId'
                },
                {
                    name: 'assumption',
                    type: 'OccupiedCoreAssumption'
                }
            ],
            type: 'ValidationCode'
        },
        validation_code_by_hash: {
            description: 'Get the validation code from its hash.',
            params: [
                {
                    name: 'hash',
                    type: 'ValidationCodeHash'
                }
            ],
            type: 'Option<ValidationCode>'
        },
        validator_groups: {
            description: 'Returns the validator groups and rotation info localized based on the hypothetical child of a block whose state  this is invoked on',
            params: [],
            type: '(Vec<Vec<ParaValidatorIndex>>, GroupRotationInfo)'
        },
        validators: {
            description: 'Get the current validators.',
            params: [],
            type: 'Vec<ValidatorId>'
        }
    };
    const PH_V2_TO_V3 = {
        pvfs_require_precheck: {
            description: 'Returns code hashes of PVFs that require pre-checking by validators in the active set.',
            params: [],
            type: 'Vec<ValidationCodeHash>'
        },
        session_info: {
            description: 'Get the session info for the given session, if stored.',
            params: [
                {
                    name: 'index',
                    type: 'SessionIndex'
                }
            ],
            type: 'Option<SessionInfo>'
        },
        submit_pvf_check_statement: {
            description: 'Submits a PVF pre-checking statement into the transaction pool.',
            params: [
                {
                    name: 'stmt',
                    type: 'PvfCheckStatement'
                },
                {
                    name: 'signature',
                    type: 'ValidatorSignature'
                }
            ],
            type: 'Null'
        },
        validation_code_hash: {
            description: 'Fetch the hash of the validation code used by a para, making the given `OccupiedCoreAssumption`.',
            params: [
                {
                    name: 'paraId',
                    type: 'ParaId'
                },
                {
                    name: 'assumption',
                    type: 'OccupiedCoreAssumption'
                }
            ],
            type: 'Option<ValidationCodeHash>'
        }
    };
    const PH_V3 = {
        disputes: {
            description: 'Returns all onchain disputes.',
            params: [],
            type: 'Vec<(SessionIndex, CandidateHash, DisputeState)>'
        }
    };
    const PH_V4 = {
        session_executor_params: {
            description: 'Returns execution parameters for the session.',
            params: [
                {
                    name: 'sessionIndex',
                    type: 'SessionIndex'
                }
            ],
            type: 'Option<ExecutorParams>'
        }
    };
    const PH_V5 = {
        key_ownership_proof: {
            description: 'Returns a merkle proof of a validator session key',
            params: [
                {
                    name: 'validatorId',
                    type: 'ValidatorId'
                }
            ],
            type: 'Option<OpaqueKeyOwnershipProof>'
        },
        submit_report_dispute_lost: {
            description: 'Submit an unsigned extrinsic to slash validators who lost a dispute about a candidate of a past session',
            params: [
                {
                    name: 'disputeProof',
                    type: 'DisputeProof'
                },
                {
                    name: 'keyOwnershipProof',
                    type: 'OpaqueKeyOwnershipProof'
                }
            ],
            type: 'Option<Null>'
        },
        unapplied_slashes: {
            description: 'Returns a list of validators that lost a past session dispute and need to be slashed',
            params: [],
            type: 'Vec<(SessionIndex, CandidateHash, PendingSlashes)>'
        }
    };
    const runtime$6 = {
        ParachainHost: [
            {
                methods: {
                    ...PH_V1_TO_V2,
                    ...PH_V2_TO_V3,
                    ...PH_V3,
                    ...PH_V4,
                    ...PH_V5
                },
                version: 5
            },
            {
                methods: {
                    ...PH_V1_TO_V2,
                    ...PH_V2_TO_V3,
                    ...PH_V3,
                    ...PH_V4
                },
                version: 4
            },
            {
                methods: {
                    ...PH_V1_TO_V2,
                    ...PH_V2_TO_V3,
                    ...PH_V3
                },
                version: 3
            },
            {
                methods: {
                    ...PH_V1_TO_V2,
                    ...PH_V2_TO_V3
                },
                version: 2
            },
            {
                methods: {
                    session_info: {
                        description: 'Get the session info for the given session, if stored.',
                        params: [
                            {
                                name: 'index',
                                type: 'SessionIndex'
                            }
                        ],
                        type: 'Option<OldV1SessionInfo>'
                    },
                    ...PH_V1_TO_V2
                },
                version: 1
            }
        ]
    };

    const SlotRange10 = {
        _enum: ['ZeroZero', 'ZeroOne', 'ZeroTwo', 'ZeroThree', 'OneOne', 'OneTwo', 'OneThree', 'TwoTwo', 'TwoThree', 'ThreeThree']
    };
    const SlotRange = {
        _enum: ['ZeroZero', 'ZeroOne', 'ZeroTwo', 'ZeroThree', 'ZeroFour', 'ZeroFive', 'ZeroSix', 'ZeroSeven', 'OneOne', 'OneTwo', 'OneThree', 'OneFour', 'OneFive', 'OneSix', 'OneSeven', 'TwoTwo', 'TwoThree', 'TwoFour', 'TwoFive', 'TwoSix', 'TwoSeven', 'ThreeThree', 'ThreeFour', 'ThreeFive', 'ThreeSix', 'ThreeSeven', 'FourFour', 'FourFive', 'FourSix', 'FourSeven', 'FiveFive', 'FiveSix', 'FiveSeven', 'SixSix', 'SixSeven', 'SevenSeven']
    };
    const oldTypes = {
        Bidder: {
            _enum: {
                New: 'NewBidder',
                Existing: 'ParaId'
            }
        },
        IncomingParachain: {
            _enum: {
                Unset: 'NewBidder',
                Fixed: 'IncomingParachainFixed',
                Deploy: 'IncomingParachainDeploy'
            }
        },
        IncomingParachainDeploy: {
            code: 'ValidationCode',
            initialHeadData: 'HeadData'
        },
        IncomingParachainFixed: {
            codeHash: 'Hash',
            codeSize: 'u32',
            initialHeadData: 'HeadData'
        },
        NewBidder: {
            who: 'AccountId',
            sub: 'SubId'
        },
        SubId: 'u32'
    };
    const slotTypes = {
        ...oldTypes,
        AuctionIndex: 'u32',
        LeasePeriod: 'BlockNumber',
        LeasePeriodOf: 'BlockNumber',
        SlotRange10,
        SlotRange,
        WinningData10: `[WinningDataEntry; ${SlotRange10._enum.length}]`,
        WinningData: `[WinningDataEntry; ${SlotRange._enum.length}]`,
        WinningDataEntry: 'Option<(AccountId, ParaId, BalanceOf)>',
        WinnersData10: 'Vec<WinnersDataTuple10>',
        WinnersData: 'Vec<WinnersDataTuple>',
        WinnersDataTuple10: '(AccountId, ParaId, BalanceOf, SlotRange10)',
        WinnersDataTuple: '(AccountId, ParaId, BalanceOf, SlotRange)'
    };

    const proposeTypes = {
        ParachainProposal: {
            proposer: 'AccountId',
            genesisHead: 'HeadData',
            validators: 'Vec<ValidatorId>',
            name: 'Bytes',
            balance: 'Balance'
        },
        RegisteredParachainInfo: {
            validators: 'Vec<ValidatorId>',
            proposer: 'AccountId'
        }
    };
    const cumulusTypes = {
        ServiceQuality: {
            _enum: ['Ordered', 'Fast']
        }
    };
    const disputeTypes = {
        DisputeLocation: {
            _enum: ['Local', 'Remote']
        },
        DisputeResult: {
            _enum: ['Valid', 'Invalid']
        },
        DisputeState: {
            validatorsFor: 'BitVec',
            validatorsAgainst: 'BitVec',
            start: 'BlockNumber',
            concludedAt: 'Option<BlockNumber>'
        },
        DisputeStatement: {
            _enum: {
                Valid: 'ValidDisputeStatementKind',
                Invalid: 'InvalidDisputeStatementKind'
            }
        },
        DisputeStatementSet: {
            candidateHash: 'CandidateHash',
            session: 'SessionIndex',
            statements: 'Vec<(DisputeStatement, ParaValidatorIndex, ValidatorSignature)>'
        },
        ExecutorParam: {
            _enum: {
                Phantom: 'Null',
                MaxMemoryPages: 'u32',
                StackLogicalMax: 'u32',
                StackNativeMax: 'u32',
                PrecheckingMaxMemory: 'u64',
                PvfPrepTimeout: '(PvfPrepTimeoutKind, u64)',
                PvfExecTimeout: '(PvfExecTimeoutKind, u64)'
            }
        },
        ExecutorParamsHash: 'Hash',
        ExecutorParams: 'Vec<ExecutorParam>',
        ExplicitDisputeStatement: {
            valid: 'bool',
            candidateHash: 'CandidateHash',
            session: 'SessionIndex'
        },
        InvalidDisputeStatementKind: {
            _enum: ['Explicit']
        },
        MultiDisputeStatementSet: 'Vec<DisputeStatementSet>',
        PvfExecTimeoutKind: {
            _enum: ['Backing', 'Approval']
        },
        PvfPrepTimeoutKind: {
            _enum: ['Precheck', 'Lenient']
        },
        ValidDisputeStatementKind: {
            _enum: {
                Explicit: 'Null',
                BackingSeconded: 'Hash',
                BackingValid: 'Hash',
                ApprovalChecking: 'Null'
            }
        }
    };
    const definitions$g = {
        rpc: {},
        runtime: runtime$6,
        types: {
            ...cumulusTypes,
            ...disputeTypes,
            ...hrmpTypes,
            ...proposeTypes,
            ...slotTypes,
            AbridgedCandidateReceipt: {
                parachainIndex: 'ParaId',
                relayParent: 'Hash',
                headData: 'HeadData',
                collator: 'CollatorId',
                signature: 'CollatorSignature',
                povBlockHash: 'Hash',
                commitments: 'CandidateCommitments'
            },
            AbridgedHostConfiguration: {
                maxCodeSize: 'u32',
                maxHeadDataSize: 'u32',
                maxUpwardQueueCount: 'u32',
                maxUpwardQueueSize: 'u32',
                maxUpwardMessageSize: 'u32',
                maxUpwardMessageNumPerCandidate: 'u32',
                hrmpMaxMessageNumPerCandidate: 'u32',
                validationUpgradeFrequency: 'BlockNumber',
                validationUpgradeDelay: 'BlockNumber'
            },
            AbridgedHrmpChannel: {
                maxCapacity: 'u32',
                maxTotalSize: 'u32',
                maxMessageSize: 'u32',
                msgCount: 'u32',
                totalSize: 'u32',
                mqcHead: 'Option<Hash>'
            },
            AssignmentId: 'AccountId',
            AssignmentKind: {
                _enum: {
                    Parachain: 'Null',
                    Parathread: '(CollatorId, u32)'
                }
            },
            AttestedCandidate: {
                candidate: 'AbridgedCandidateReceipt',
                validityVotes: 'Vec<ValidityAttestation>',
                validatorIndices: 'BitVec'
            },
            AuthorityDiscoveryId: 'AccountId',
            AvailabilityBitfield: 'BitVec',
            AvailabilityBitfieldRecord: {
                bitfield: 'AvailabilityBitfield',
                submittedTt: 'BlockNumber'
            },
            BackedCandidate: {
                candidate: 'CommittedCandidateReceipt',
                validityVotes: 'Vec<ValidityAttestation>',
                validatorIndices: 'BitVec'
            },
            BufferedSessionChange: {
                applyAt: 'BlockNumber',
                validators: 'Vec<ValidatorId>',
                queued: 'Vec<ValidatorId>',
                sessionIndex: 'SessionIndex'
            },
            CandidateCommitments: {
                upwardMessages: 'Vec<UpwardMessage>',
                horizontalMessages: 'Vec<OutboundHrmpMessage>',
                newValidationCode: 'Option<ValidationCode>',
                headData: 'HeadData',
                processedDownwardMessages: 'u32',
                hrmpWatermark: 'BlockNumber'
            },
            CandidateDescriptor: {
                paraId: 'ParaId',
                relayParent: 'RelayChainHash',
                collatorId: 'CollatorId',
                persistedValidationDataHash: 'Hash',
                povHash: 'Hash',
                erasureRoot: 'Hash',
                signature: 'CollatorSignature',
                paraHead: 'Hash',
                validationCodeHash: 'ValidationCodeHash'
            },
            CandidateEvent: {
                _enum: {
                    CandidateBacked: '(CandidateReceipt, HeadData, CoreIndex, GroupIndex)',
                    CandidateIncluded: '(CandidateReceipt, HeadData, CoreIndex, GroupIndex)',
                    CandidateTimedOut: '(CandidateReceipt, HeadData, CoreIndex)'
                }
            },
            CandidateHash: 'Hash',
            CandidateInfo: {
                who: 'AccountId',
                deposit: 'Balance'
            },
            CandidatePendingAvailability: {
                core: 'CoreIndex',
                hash: 'CandidateHash',
                descriptor: 'CandidateDescriptor',
                availabilityVotes: 'BitVec',
                backers: 'BitVec',
                relayParentNumber: 'BlockNumber',
                backedInNumber: 'BlockNumber',
                backingGroup: 'GroupIndex'
            },
            CandidateReceipt: {
                descriptor: 'CandidateDescriptor',
                commitmentsHash: 'Hash'
            },
            GlobalValidationData: {
                maxCodeSize: 'u32',
                maxHeadDataSize: 'u32',
                blockNumber: 'BlockNumber'
            },
            CollatorId: 'H256',
            CollatorSignature: 'Signature',
            CommittedCandidateReceipt: {
                descriptor: 'CandidateDescriptor',
                commitments: 'CandidateCommitments'
            },
            CoreAssignment: {
                core: 'CoreIndex',
                paraId: 'ParaId',
                kind: 'AssignmentKind',
                groupIdx: 'GroupIndex'
            },
            CoreIndex: 'u32',
            CoreOccupied: {
                _enum: {
                    Parathread: 'ParathreadEntry',
                    Parachain: 'Null'
                }
            },
            CoreState: {
                _enum: {
                    Occupied: 'OccupiedCore',
                    Scheduled: 'ScheduledCore',
                    Free: 'Null'
                }
            },
            DisputeProof: {
                timeSlot: 'DisputesTimeSlot',
                kind: 'SlashingOffenceKind',
                validatorIndex: 'ValidatorIndex',
                validatorId: 'ValidatorId'
            },
            DisputesTimeSlot: {
                sessionIndex: 'SessionIndex',
                candidateHash: 'CandidateHash'
            },
            DoubleVoteReport: {
                identity: 'ValidatorId',
                first: '(Statement, ValidatorSignature)',
                second: '(Statement, ValidatorSignature)',
                proof: 'MembershipProof',
                signingContext: 'SigningContext'
            },
            DownwardMessage: 'Bytes',
            GroupIndex: 'u32',
            GroupRotationInfo: {
                sessionStartBlock: 'BlockNumber',
                groupRotationFrequency: 'BlockNumber',
                now: 'BlockNumber'
            },
            GlobalValidationSchedule: {
                maxCodeSize: 'u32',
                maxHeadDataSize: 'u32',
                blockNumber: 'BlockNumber'
            },
            HeadData: 'Bytes',
            HostConfiguration: {
                maxCodeSize: 'u32',
                maxHeadDataSize: 'u32',
                maxUpwardQueueCount: 'u32',
                maxUpwardQueueSize: 'u32',
                maxUpwardMessageSize: 'u32',
                maxUpwardMessageNumPerCandidate: 'u32',
                hrmpMaxMessageNumPerCandidate: 'u32',
                validationUpgradeFrequency: 'BlockNumber',
                validationUpgradeDelay: 'BlockNumber',
                maxPovSize: 'u32',
                maxDownwardMessageSize: 'u32',
                preferredDispatchableUpwardMessagesStepWeight: 'Weight',
                hrmpMaxParachainOutboundChannels: 'u32',
                hrmpMaxParathreadOutboundChannels: 'u32',
                hrmpOpenRequestTtl: 'u32',
                hrmpSenderDeposit: 'Balance',
                hrmpRecipientDeposit: 'Balance',
                hrmpChannelMaxCapacity: 'u32',
                hrmpChannelMaxTotalSize: 'u32',
                hrmpMaxParachainInboundChannels: 'u32',
                hrmpMaxParathreadInboundChannels: 'u32',
                hrmpChannelMaxMessageSize: 'u32',
                codeRetentionPeriod: 'BlockNumber',
                parathreadCores: 'u32',
                parathreadRetries: 'u32',
                groupRotationFrequency: 'BlockNumber',
                chainAvailabilityPeriod: 'BlockNumber',
                threadAvailabilityPeriod: 'BlockNumber',
                schedulingLookahead: 'u32',
                maxValidatorsPerCore: 'Option<u32>',
                maxValidators: 'Option<u32>',
                disputePeriod: 'SessionIndex',
                disputePostConclusionAcceptancePeriod: 'BlockNumber',
                disputeMaxSpamSlots: 'u32',
                disputeConclusionByTimeOutPeriod: 'BlockNumber',
                noShowSlots: 'u32',
                nDelayTranches: 'u32',
                zerothDelayTrancheWidth: 'u32',
                neededApprovals: 'u32',
                relayVrfModuloSamples: 'u32'
            },
            InboundDownwardMessage: {
                pubSentAt: 'BlockNumber',
                pubMsg: 'DownwardMessage'
            },
            InboundHrmpMessage: {
                sentAt: 'BlockNumber',
                data: 'Bytes'
            },
            InboundHrmpMessages: 'Vec<InboundHrmpMessage>',
            LocalValidationData: {
                parentHead: 'HeadData',
                balance: 'Balance',
                codeUpgradeAllowed: 'Option<BlockNumber>'
            },
            MessageIngestionType: {
                downwardMessages: 'Vec<InboundDownwardMessage>',
                horizontalMessages: 'BTreeMap<ParaId, InboundHrmpMessages>'
            },
            MessageQueueChain: 'RelayChainHash',
            OccupiedCore: {
                nextUpOnAvailable: 'Option<ScheduledCore>',
                occupiedSince: 'BlockNumber',
                timeOutAt: 'BlockNumber',
                nextUpOnTimeOut: 'Option<ScheduledCore>',
                availability: 'BitVec',
                groupResponsible: 'GroupIndex',
                candidateHash: 'CandidateHash',
                candidateDescriptor: 'CandidateDescriptor'
            },
            OccupiedCoreAssumption: {
                _enum: ['Included,', 'TimedOut', 'Free']
            },
            OutboundHrmpMessage: {
                recipient: 'u32',
                data: 'Bytes'
            },
            PendingSlashes: {
                _alias: {
                    slashKeys: 'keys'
                },
                slashKeys: 'BTreeMap<ValidatorIndex, ValidatorId>',
                kind: 'SlashingOffenceKind'
            },
            ParachainDispatchOrigin: {
                _enum: ['Signed', 'Parachain', 'Root']
            },
            ParachainInherentData: {
                validationData: 'PersistedValidationData',
                relayChainState: 'StorageProof',
                downwardMessages: 'Vec<InboundDownwardMessage>',
                horizontalMessages: 'BTreeMap<ParaId, VecInboundHrmpMessage>'
            },
            ParachainsInherentData: {
                bitfields: 'SignedAvailabilityBitfields',
                backedCandidates: 'Vec<BackedCandidate>',
                disputes: 'MultiDisputeStatementSet',
                parentHeader: 'Header'
            },
            ParaGenesisArgs: {
                genesisHead: 'Bytes',
                validationCode: 'Bytes',
                parachain: 'bool'
            },
            ParaId: 'u32',
            ParaInfo: {
                manager: 'AccountId',
                deposit: 'Balance',
                locked: 'bool'
            },
            ParaLifecycle: {
                _enum: ['Onboarding', 'Parathread', 'Parachain', 'UpgradingToParachain', 'DowngradingToParathread', 'OutgoingParathread', 'OutgoingParachain']
            },
            ParaPastCodeMeta: {
                upgradeTimes: 'Vec<ReplacementTimes>',
                lastPruned: 'Option<BlockNumber>'
            },
            ParaScheduling: {
                _enum: ['Always', 'Dynamic']
            },
            ParathreadClaim: '(ParaId, CollatorId)',
            ParathreadClaimQueue: {
                queue: 'Vec<QueuedParathread>',
                nextCoreOffset: 'u32'
            },
            ParathreadEntry: {
                claim: 'ParathreadClaim',
                retries: 'u32'
            },
            ParaValidatorIndex: 'u32',
            PersistedValidationData: {
                parentHead: 'HeadData',
                relayParentNumber: 'RelayChainBlockNumber',
                relayParentStorageRoot: 'Hash',
                maxPovSize: 'u32'
            },
            PvfCheckStatement: {
                accept: 'bool',
                subject: 'ValidationCodeHash',
                sessionIndex: 'SessionIndex',
                validatorIndex: 'ParaValidatorIndex'
            },
            QueuedParathread: {
                claim: 'ParathreadEntry',
                coreOffset: 'u32'
            },
            RelayBlockNumber: 'u32',
            RelayChainBlockNumber: 'RelayBlockNumber',
            RelayHash: 'Hash',
            RelayChainHash: 'RelayHash',
            Remark: '[u8; 32]',
            ReplacementTimes: {
                expectedAt: 'BlockNumber',
                activatedAt: 'BlockNumber'
            },
            Retriable: {
                _enum: {
                    Never: 'Null',
                    WithRetries: 'u32'
                }
            },
            ScheduledCore: {
                paraId: 'ParaId',
                collator: 'Option<CollatorId>'
            },
            Scheduling: {
                _enum: ['Always', 'Dynamic']
            },
            ScrapedOnChainVotes: {
                session: 'SessionIndex',
                backingValidatorsPerCandidate: 'Vec<(CandidateReceipt, Vec<(ParaValidatorIndex, ValidityAttestation)>)>',
                disputes: 'MultiDisputeStatementSet'
            },
            SessionInfo: {
                activeValidatorIndices: 'Vec<ParaValidatorIndex>',
                randomSeed: '[u8; 32]',
                disputePeriod: 'SessionIndex',
                validators: 'Vec<ValidatorId>',
                discoveryKeys: 'Vec<AuthorityDiscoveryId>',
                assignmentKeys: 'Vec<AssignmentId>',
                validatorGroups: 'Vec<Vec<ValidatorIndex>>',
                nCores: 'u32',
                zerothDelayTrancheWidth: 'u32',
                relayVrfModuloSamples: 'u32',
                nDelayTranches: 'u32',
                noShowSlots: 'u32',
                neededApprovals: 'u32'
            },
            OldV1SessionInfo: {
                validators: 'Vec<ValidatorId>',
                discoveryKeys: 'Vec<AuthorityDiscoveryId>',
                assignmentKeys: 'Vec<AssignmentId>',
                validatorGroups: 'Vec<Vec<ParaValidatorIndex>>',
                nCores: 'u32',
                zerothDelayTrancheWidth: 'u32',
                relayVrfModuloSamples: 'u32',
                nDelayTranches: 'u32',
                noShowSlots: 'u32',
                neededApprovals: 'u32'
            },
            SessionInfoValidatorGroup: 'Vec<ParaValidatorIndex>',
            SignedAvailabilityBitfield: {
                payload: 'BitVec',
                validatorIndex: 'ParaValidatorIndex',
                signature: 'ValidatorSignature'
            },
            SignedAvailabilityBitfields: 'Vec<SignedAvailabilityBitfield>',
            SigningContext: {
                sessionIndex: 'SessionIndex',
                parentHash: 'Hash'
            },
            SlashingOffenceKind: {
                _enum: ['ForInvalid', 'AgainstValid']
            },
            Statement: {
                _enum: {
                    Never: 'Null',
                    Candidate: 'Hash',
                    Valid: 'Hash',
                    Invalid: 'Hash'
                }
            },
            TransientValidationData: {
                maxCodeSize: 'u32',
                maxHeadDataSize: 'u32',
                balance: 'Balance',
                codeUpgradeAllowed: 'Option<BlockNumber>',
                dmqLength: 'u32'
            },
            UpgradeGoAhead: {
                _enum: ['Abort', 'GoAhead']
            },
            UpgradeRestriction: {
                _enum: ['Present']
            },
            UpwardMessage: 'Bytes',
            ValidationFunctionParams: {
                maxCodeSize: 'u32',
                relayChainHeight: 'RelayChainBlockNumber',
                codeUpgradeAllowed: 'Option<RelayChainBlockNumber>'
            },
            ValidationCode: 'Bytes',
            ValidationCodeHash: 'Hash',
            ValidationData: {
                persisted: 'PersistedValidationData',
                transient: 'TransientValidationData'
            },
            ValidationDataType: {
                validationData: 'ValidationData',
                relayChainState: 'Vec<Bytes>'
            },
            ValidatorSignature: 'Signature',
            ValidityAttestation: {
                _enum: {
                    Never: 'Null',
                    Implicit: 'ValidatorSignature',
                    Explicit: 'ValidatorSignature'
                }
            },
            MessagingStateSnapshot: {
                relayDispatchQueueSize: '(u32, u32)',
                egressChannels: 'Vec<MessagingStateSnapshotEgressEntry>'
            },
            MessagingStateSnapshotEgressEntry: '(ParaId, AbridgedHrmpChannel)',
            SystemInherentData: 'ParachainInherentData',
            VecInboundHrmpMessage: 'Vec<InboundHrmpMessage>'
        }
    };

    const definitions$f = {
        rpc: {},
        types: {
            Approvals: '[bool; 4]'
        }
    };

    const definitions$e = {
        rpc: {},
        types: {
            AccountStatus: {
                validity: 'AccountValidity',
                freeBalance: 'Balance',
                lockedBalance: 'Balance',
                signature: 'Vec<u8>',
                vat: 'Permill'
            },
            AccountValidity: {
                _enum: ['Invalid', 'Initiated', 'Pending', 'ValidLow', 'ValidHigh', 'Completed']
            }
        }
    };

    exports.TypeDefInfo = void 0;
    (function (TypeDefInfo) {
        TypeDefInfo[TypeDefInfo["BTreeMap"] = 0] = "BTreeMap";
        TypeDefInfo[TypeDefInfo["BTreeSet"] = 1] = "BTreeSet";
        TypeDefInfo[TypeDefInfo["Compact"] = 2] = "Compact";
        TypeDefInfo[TypeDefInfo["DoNotConstruct"] = 3] = "DoNotConstruct";
        TypeDefInfo[TypeDefInfo["Enum"] = 4] = "Enum";
        TypeDefInfo[TypeDefInfo["HashMap"] = 5] = "HashMap";
        TypeDefInfo[TypeDefInfo["Int"] = 6] = "Int";
        TypeDefInfo[TypeDefInfo["Linkage"] = 7] = "Linkage";
        TypeDefInfo[TypeDefInfo["Null"] = 8] = "Null";
        TypeDefInfo[TypeDefInfo["Option"] = 9] = "Option";
        TypeDefInfo[TypeDefInfo["Plain"] = 10] = "Plain";
        TypeDefInfo[TypeDefInfo["Range"] = 11] = "Range";
        TypeDefInfo[TypeDefInfo["RangeInclusive"] = 12] = "RangeInclusive";
        TypeDefInfo[TypeDefInfo["Result"] = 13] = "Result";
        TypeDefInfo[TypeDefInfo["Set"] = 14] = "Set";
        TypeDefInfo[TypeDefInfo["Si"] = 15] = "Si";
        TypeDefInfo[TypeDefInfo["Struct"] = 16] = "Struct";
        TypeDefInfo[TypeDefInfo["Tuple"] = 17] = "Tuple";
        TypeDefInfo[TypeDefInfo["UInt"] = 18] = "UInt";
        TypeDefInfo[TypeDefInfo["Vec"] = 19] = "Vec";
        TypeDefInfo[TypeDefInfo["VecFixed"] = 20] = "VecFixed";
        TypeDefInfo[TypeDefInfo["WrapperKeepOpaque"] = 21] = "WrapperKeepOpaque";
        TypeDefInfo[TypeDefInfo["WrapperOpaque"] = 22] = "WrapperOpaque";
    })(exports.TypeDefInfo || (exports.TypeDefInfo = {}));

    function hasEq(o) {
        return util.isFunction(o.eq);
    }

    function compareArray(a, b) {
        if (Array.isArray(b)) {
            return (a.length === b.length) && util.isUndefined(a.find((v, index) => hasEq(v)
                ? !v.eq(b[index])
                : v !== b[index]));
        }
        return false;
    }

    class AbstractArray extends Array {
        registry;
        createdAtHash;
        initialU8aLength;
        isStorageFallback;
        static get [Symbol.species]() {
            return Array;
        }
        constructor(registry, length) {
            super(length);
            this.registry = registry;
        }
        get encodedLength() {
            const count = this.length;
            let total = util.compactToU8a(count).length;
            for (let i = 0; i < count; i++) {
                total += this[i].encodedLength;
            }
            return total;
        }
        get hash() {
            return this.registry.hash(this.toU8a());
        }
        get isEmpty() {
            return this.length === 0;
        }
        get length() {
            return super.length;
        }
        eq(other) {
            return compareArray(this, other);
        }
        inspect() {
            return {
                inner: this.inspectInner(),
                outer: [util.compactToU8a(this.length)]
            };
        }
        inspectInner() {
            const count = this.length;
            const inner = new Array(count);
            for (let i = 0; i < count; i++) {
                inner[i] = this[i].inspect();
            }
            return inner;
        }
        toArray() {
            return Array.from(this);
        }
        toHex() {
            return util.u8aToHex(this.toU8a());
        }
        toHuman(isExtended) {
            const count = this.length;
            const result = new Array(count);
            for (let i = 0; i < count; i++) {
                result[i] = this[i] && this[i].toHuman(isExtended);
            }
            return result;
        }
        toJSON() {
            const count = this.length;
            const result = new Array(count);
            for (let i = 0; i < count; i++) {
                result[i] = this[i] && this[i].toJSON();
            }
            return result;
        }
        toPrimitive() {
            const count = this.length;
            const result = new Array(count);
            for (let i = 0; i < count; i++) {
                result[i] = this[i] && this[i].toPrimitive();
            }
            return result;
        }
        toString() {
            const count = this.length;
            const result = new Array(count);
            for (let i = 0; i < count; i++) {
                result[i] = this[i].toString();
            }
            return `[${result.join(', ')}]`;
        }
        toU8a(isBare) {
            const encoded = this.toU8aInner();
            return isBare
                ? util.u8aConcatStrict(encoded)
                : util.u8aConcatStrict([util.compactToU8a(this.length), ...encoded]);
        }
        toU8aInner(isBare) {
            const count = this.length;
            const encoded = new Array(count);
            for (let i = 0; i < count; i++) {
                encoded[i] = this[i].toU8a(isBare);
            }
            return encoded;
        }
    }

    class AbstractBase {
        registry;
        createdAtHash;
        initialU8aLength;
        isStorageFallback;
        __internal__raw;
        constructor(registry, value, initialU8aLength) {
            this.initialU8aLength = initialU8aLength;
            this.__internal__raw = value;
            this.registry = registry;
        }
        get encodedLength() {
            return this.toU8a().length;
        }
        get hash() {
            return this.registry.hash(this.toU8a());
        }
        get inner() {
            return this.__internal__raw;
        }
        get isEmpty() {
            return this.__internal__raw.isEmpty;
        }
        eq(other) {
            return this.__internal__raw.eq(other);
        }
        inspect() {
            return this.__internal__raw.inspect();
        }
        toHex(isLe) {
            return this.__internal__raw.toHex(isLe);
        }
        toHuman(isExtended) {
            return this.__internal__raw.toHuman(isExtended);
        }
        toJSON() {
            return this.__internal__raw.toJSON();
        }
        toPrimitive() {
            return this.__internal__raw.toPrimitive();
        }
        toString() {
            return this.__internal__raw.toString();
        }
        toU8a(isBare) {
            return this.__internal__raw.toU8a(isBare);
        }
        unwrap() {
            return this.__internal__raw;
        }
        valueOf() {
            return this.__internal__raw;
        }
    }

    const DEFAULT_UINT_BITS = 64;
    const MAX_NUMBER_BITS = 52;
    const MUL_P = new util.BN(10000);
    const FORMATTERS = [
        ['Perquintill', util.BN_QUINTILL],
        ['Perbill', util.BN_BILLION],
        ['Permill', util.BN_MILLION],
        ['Percent', util.BN_HUNDRED]
    ];
    function isToBn(value) {
        return util.isFunction(value.toBn);
    }
    function toPercentage(value, divisor) {
        return `${(value.mul(MUL_P).div(divisor).toNumber() / 100).toFixed(2)}%`;
    }
    function decodeAbstractInt(value, isNegative) {
        if (util.isNumber(value)) {
            if (!Number.isInteger(value) || value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER) {
                throw new Error('Number needs to be an integer <= Number.MAX_SAFE_INTEGER, i.e. 2 ^ 53 - 1');
            }
            return value;
        }
        else if (util.isString(value)) {
            if (util.isHex(value, -1, true)) {
                return util.hexToBn(value, { isLe: false, isNegative }).toString();
            }
            if (value.includes('.') || value.includes(',') || value.includes('e')) {
                throw new Error('String should not contain decimal points or scientific notation');
            }
            return value;
        }
        else if (util.isBn(value) || util.isBigInt(value)) {
            return value.toString();
        }
        else if (util.isObject(value)) {
            if (isToBn(value)) {
                return value.toBn().toString();
            }
            const keys = Object.keys(value);
            if (keys.length !== 1) {
                throw new Error('Unable to construct number from multi-key object');
            }
            return decodeAbstractInt(value[keys[0]], isNegative);
        }
        else if (!value) {
            return 0;
        }
        throw new Error(`Unable to create BN from unknown type ${typeof value}`);
    }
    class AbstractInt extends util.BN {
        registry;
        encodedLength;
        isUnsigned;
        createdAtHash;
        initialU8aLength;
        isStorageFallback;
        __internal__bitLength;
        constructor(registry, value = 0, bitLength = DEFAULT_UINT_BITS, isSigned = false) {
            super(
            util.isU8a(value)
                ? bitLength <= 48
                    ? util.u8aToNumber(value.subarray(0, bitLength / 8), { isNegative: isSigned })
                    : util.u8aToBn(value.subarray(0, bitLength / 8), { isLe: true, isNegative: isSigned }).toString()
                : decodeAbstractInt(value, isSigned));
            this.registry = registry;
            this.__internal__bitLength = bitLength;
            this.encodedLength = this.__internal__bitLength / 8;
            this.initialU8aLength = this.__internal__bitLength / 8;
            this.isUnsigned = !isSigned;
            const isNegative = this.isNeg();
            const maxBits = bitLength - (isSigned && !isNegative ? 1 : 0);
            if (isNegative && !isSigned) {
                throw new Error(`${this.toRawType()}: Negative number passed to unsigned type`);
            }
            else if (super.bitLength() > maxBits) {
                throw new Error(`${this.toRawType()}: Input too large. Found input with ${super.bitLength()} bits, expected ${maxBits}`);
            }
        }
        get hash() {
            return this.registry.hash(this.toU8a());
        }
        get isEmpty() {
            return this.isZero();
        }
        bitLength() {
            return this.__internal__bitLength;
        }
        eq(other) {
            return super.eq(util.isHex(other)
                ? util.hexToBn(other.toString(), { isLe: false, isNegative: !this.isUnsigned })
                : util.bnToBn(other));
        }
        inspect() {
            return {
                outer: [this.toU8a()]
            };
        }
        isMax() {
            const u8a = this.toU8a().filter((b) => b === 0xff);
            return u8a.length === (this.__internal__bitLength / 8);
        }
        toBigInt() {
            return BigInt(this.toString());
        }
        toBn() {
            return this;
        }
        toHex(isLe = false) {
            return util.bnToHex(this, {
                bitLength: this.bitLength(),
                isLe,
                isNegative: !this.isUnsigned
            });
        }
        toHuman(_isExpanded) {
            const rawType = this.toRawType();
            if (rawType === 'Balance') {
                return this.isMax()
                    ? 'everything'
                    : util.formatBalance(this, { decimals: this.registry.chainDecimals[0], withSi: true, withUnit: this.registry.chainTokens[0] });
            }
            const [, divisor] = FORMATTERS.find(([type]) => type === rawType) || [];
            return divisor
                ? toPercentage(this, divisor)
                : util.formatNumber(this);
        }
        toJSON(onlyHex = false) {
            return onlyHex || (this.__internal__bitLength > 128) || (super.bitLength() > MAX_NUMBER_BITS)
                ? this.toHex()
                : this.toNumber();
        }
        toPrimitive() {
            return super.bitLength() > MAX_NUMBER_BITS
                ? this.toString()
                : this.toNumber();
        }
        toRawType() {
            return this instanceof this.registry.createClassUnsafe('Balance')
                ? 'Balance'
                : `${this.isUnsigned ? 'u' : 'i'}${this.bitLength()}`;
        }
        toString(base) {
            return super.toString(base);
        }
        toU8a(_isBare) {
            return util.bnToU8a(this, {
                bitLength: this.bitLength(),
                isLe: true,
                isNegative: !this.isUnsigned
            });
        }
    }

    function hasMismatch(a, b) {
        return util.isUndefined(a) || (hasEq(a)
            ? !a.eq(b)
            : a !== b);
    }
    function notEntry(value) {
        return !Array.isArray(value) || value.length !== 2;
    }
    function compareMapArray(a, b) {
        return (a.size === b.length) && !b.some((e) => notEntry(e) ||
            hasMismatch(a.get(e[0]), e[1]));
    }
    function compareMap(a, b) {
        if (Array.isArray(b)) {
            return compareMapArray(a, b);
        }
        else if (b instanceof Map) {
            return compareMapArray(a, [...b.entries()]);
        }
        else if (util.isObject(b)) {
            return compareMapArray(a, Object.entries(b));
        }
        return false;
    }

    function compareSetArray(a, b) {
        return (a.size === b.length) && !b.some((e) => !a.has(e));
    }
    function compareSet(a, b) {
        if (Array.isArray(b)) {
            return compareSetArray(a, b);
        }
        else if (b instanceof Set) {
            return compareSetArray(a, [...b.values()]);
        }
        else if (util.isObject(b)) {
            return compareSetArray(a, Object.values(b));
        }
        return false;
    }

    function formatFailure(registry, fn, _result, { message }, u8a, i, count, Type, key) {
        let type = '';
        try {
            type = `: ${new Type(registry).toRawType()}`;
        }
        catch {
        }
        return `${fn}: failed at ${util.u8aToHex(u8a.subarray(0, 16))}…${key ? ` on ${key}` : ''} (index ${i + 1}/${count})${type}:: ${message}`;
    }
    function decodeU8a$6(registry, result, u8a, [Types, keys]) {
        const count = result.length;
        let offset = 0;
        let i = 0;
        try {
            while (i < count) {
                const value = new Types[i](registry, u8a.subarray(offset));
                offset += value.initialU8aLength || value.encodedLength;
                result[i] = value;
                i++;
            }
        }
        catch (error) {
            throw new Error(formatFailure(registry, 'decodeU8a', result, error, u8a.subarray(offset), i, count, Types[i], keys[i]));
        }
        return [result, offset];
    }
    function decodeU8aStruct(registry, result, u8a, [Types, keys]) {
        const count = result.length;
        let offset = 0;
        let i = 0;
        try {
            while (i < count) {
                const value = new Types[i](registry, u8a.subarray(offset));
                offset += value.initialU8aLength || value.encodedLength;
                result[i] = [keys[i], value];
                i++;
            }
        }
        catch (error) {
            throw new Error(formatFailure(registry, 'decodeU8aStruct', result, error, u8a.subarray(offset), i, count, Types[i], keys[i]));
        }
        return [result, offset];
    }
    function decodeU8aVec(registry, result, u8a, startAt, Type) {
        const count = result.length;
        let offset = startAt;
        let i = 0;
        try {
            while (i < count) {
                const value = new Type(registry, u8a.subarray(offset));
                offset += value.initialU8aLength || value.encodedLength;
                result[i] = value;
                i++;
            }
        }
        catch (error) {
            throw new Error(formatFailure(registry, 'decodeU8aVec', result, error, u8a.subarray(offset), i, count, Type));
        }
        return [offset, offset - startAt];
    }

    const BOUNDED = ['BTreeMap', 'BTreeSet', 'HashMap', 'Vec'];
    const ALLOWED_BOXES = BOUNDED.concat(['Compact', 'DoNotConstruct', 'Int', 'Linkage', 'Range', 'RangeInclusive', 'Result', 'Opaque', 'Option', 'UInt', 'WrapperKeepOpaque', 'WrapperOpaque']);
    const BOX_PRECEDING = ['<', '(', '[', '"', ',', ' '];
    const mappings = [
        alias('<T::InherentOfflineReport as InherentOfflineReport>::Inherent', 'InherentOfflineReport', false),
        alias('VecDeque<', 'Vec<', false),
        cleanupCompact(),
        removeExtensions('Bounded', true),
        removeExtensions('Weak', false),
        removeTraits(),
        removePairOf(),
        removeWrap('Box<'),
        removeGenerics(),
        alias('String', 'Text'),
        alias('Vec<u8>', 'Bytes'),
        alias('&\\[u8\\]', 'Bytes'),
        alias("&'static\\[u8\\]", 'Bytes'),
        alias('RawAddress', 'Address'),
        alias('Lookup::Source', 'LookupSource'),
        alias('Lookup::Target', 'LookupTarget'),
        alias('exec::StorageKey', 'ContractStorageKey'),
        flattenSingleTuple(),
        removeColons(),
        trim()
    ];
    function trim() {
        return (value) => value.trim();
    }
    function findClosing(value, start) {
        let depth = 0;
        for (let i = start, count = value.length; i < count; i++) {
            if (value[i] === '>') {
                if (!depth) {
                    return i;
                }
                depth--;
            }
            else if (value[i] === '<') {
                depth++;
            }
        }
        throw new Error(`Unable to find closing matching <> on '${value}' (start ${start})`);
    }
    function alias(src, dest, withChecks = true) {
        const from = new RegExp(`(^${src}|${BOX_PRECEDING.map((box) => `\\${box}${src}`).join('|')})`, 'g');
        const to = (src) => {
            from.lastIndex = 0;
            return withChecks && BOX_PRECEDING.includes(src[0])
                ? `${src[0]}${dest}`
                : dest;
        };
        return (value) => value.replace(from, to);
    }
    function cleanupCompact() {
        return (value) => {
            if (value.includes(' as HasCompact')) {
                for (let i = 0, count = value.length; i < count; i++) {
                    if (value[i] === '<') {
                        const end = findClosing(value, i + 1) - 14;
                        if (value.substring(end, end + 14) === ' as HasCompact') {
                            value = `Compact<${value.substring(i + 1, end)}>`;
                        }
                    }
                }
            }
            return value;
        };
    }
    function flattenSingleTuple() {
        const from1 = /,\)/g;
        const from2 = /\(([^,]+)\)/;
        return (value) => {
            from1.lastIndex = 0;
            return value
                .replace(from1, ')')
                .replace(from2, '$1');
        };
    }
    function replaceTagWith(value, matcher, replacer) {
        let index = -1;
        while (true) {
            index = value.indexOf(matcher, index + 1);
            if (index === -1) {
                return value;
            }
            const start = index + matcher.length;
            const end = findClosing(value, start);
            value = `${value.substring(0, index)}${replacer(value.substring(start, end))}${value.substring(end + 1)}`;
        }
    }
    function removeExtensions(type, isSized) {
        return (value) => {
            for (let i = 0, count = BOUNDED.length; i < count; i++) {
                const tag = BOUNDED[i];
                value = replaceTagWith(value, `${type}${tag}<`, (v) => {
                    const parts = v
                        .split(',')
                        .map((s) => s.trim())
                        .filter((s) => s);
                    if (isSized) {
                        parts.pop();
                    }
                    return `${tag}<${parts.join(',')}>`;
                });
            }
            return value;
        };
    }
    function removeColons() {
        return (value) => {
            let index = 0;
            while (index !== -1) {
                index = value.indexOf('::');
                if (index === 0) {
                    value = value.substring(2);
                }
                else if (index !== -1) {
                    let start = index;
                    while (start !== -1 && !BOX_PRECEDING.includes(value[start])) {
                        start--;
                    }
                    value = `${value.substring(0, start + 1)}${value.substring(index + 2)}`;
                }
            }
            return value;
        };
    }
    function removeGenerics() {
        return (value) => {
            for (let i = 0, count = value.length; i < count; i++) {
                if (value[i] === '<') {
                    const box = ALLOWED_BOXES.find((box) => {
                        const start = i - box.length;
                        return ((start >= 0 &&
                            value.substring(start, i) === box) && (
                        start === 0 ||
                            BOX_PRECEDING.includes(value[start - 1])));
                    });
                    if (!box) {
                        const end = findClosing(value, i + 1);
                        value = `${value.substring(0, i)}${value.substring(end + 1)}`;
                    }
                }
            }
            return value;
        };
    }
    function removePairOf() {
        const replacer = (v) => `(${v},${v})`;
        return (value) => replaceTagWith(value, 'PairOf<', replacer);
    }
    function removeTraits() {
        const from1 = /\s/g;
        const from2 = /(T|Self)::/g;
        const from3 = /<(T|Self)asTrait>::/g;
        const from4 = /<Tas[a-z]+::Trait>::/g;
        const from5 = /<LookupasStaticLookup>/g;
        const from6 = /::Type/g;
        return (value) => {
            from1.lastIndex = 0;
            from2.lastIndex = 0;
            from3.lastIndex = 0;
            from4.lastIndex = 0;
            from5.lastIndex = 0;
            from6.lastIndex = 0;
            return value
                .replace(from1, '')
                .replace(from2, '')
                .replace(from3, '')
                .replace(from4, '')
                .replace(from5, 'Lookup')
                .replace(from6, '');
        };
    }
    function removeWrap(check) {
        const replacer = (v) => v;
        return (value) => replaceTagWith(value, check, replacer);
    }
    const sanitizeMap = new Map();
    function sanitize(value) {
        const startValue = value.toString();
        const memoized = sanitizeMap.get(startValue);
        if (memoized) {
            return memoized;
        }
        let result = startValue;
        for (let i = 0, count = mappings.length; i < count; i++) {
            result = mappings[i](result);
        }
        sanitizeMap.set(startValue, result);
        return result;
    }

    function isArrayLike(arg) {
        return arg instanceof Uint8Array || Array.isArray(arg);
    }
    function isEnum(arg) {
        return util.isCodec(arg) && util.isNumber(arg.index) && util.isCodec(arg.value);
    }
    function isNumberLike(arg) {
        return util.isNumber(arg) || util.isBn(arg) || util.isBigInt(arg);
    }
    function sortArray(a, b) {
        let sortRes = 0;
        const minLen = Math.min(a.length, b.length);
        for (let i = 0; i < minLen; ++i) {
            sortRes = sortAsc(a[i], b[i]);
            if (sortRes !== 0) {
                return sortRes;
            }
        }
        return a.length - b.length;
    }
    function sortAsc(a, b) {
        if (isNumberLike(a) && isNumberLike(b)) {
            return util.bnToBn(a).cmp(util.bnToBn(b));
        }
        else if (a instanceof Map && b instanceof Map) {
            return sortAsc(Array.from(a.values()), Array.from(b.values()));
        }
        else if (isEnum(a) && isEnum(b)) {
            return sortAsc(a.index, b.index) || sortAsc(a.value, b.value);
        }
        else if (isArrayLike(a) && isArrayLike(b)) {
            return sortArray(a, b);
        }
        else if (util.isCodec(a) && util.isCodec(b)) {
            return sortAsc(a.toU8a(true), b.toU8a(true));
        }
        throw new Error(`Attempting to sort unrecognized values: ${util.stringify(a)} (typeof ${typeof a}) <-> ${util.stringify(b)} (typeof ${typeof b})`);
    }
    function sortSet(set) {
        return new Set(Array.from(set).sort(sortAsc));
    }
    function sortMap(map) {
        return new Map(Array.from(map.entries()).sort(([keyA], [keyB]) => sortAsc(keyA, keyB)));
    }

    function typeToConstructor(registry, type) {
        return typeof type === 'function'
            ? type
            : registry.createClassUnsafe(type);
    }
    function typesToConstructors(registry, types) {
        const count = types.length;
        const result = new Array(count);
        for (let i = 0; i < count; i++) {
            result[i] = typeToConstructor(registry, types[i]);
        }
        return result;
    }
    function mapToTypeMap(registry, input) {
        const entries = Object.entries(input);
        const count = entries.length;
        const output = [new Array(count), new Array(count)];
        for (let i = 0; i < count; i++) {
            output[1][i] = entries[i][0];
            output[0][i] = typeToConstructor(registry, entries[i][1]);
        }
        return output;
    }

    function typesToMap(registry, [Types, keys]) {
        const result = {};
        for (let i = 0, count = keys.length; i < count; i++) {
            result[keys[i]] = registry.getClassName(Types[i]) || new Types[i](registry).toRawType();
        }
        return result;
    }

    function decodeCompact(registry, Type, value) {
        if (util.isU8a(value)) {
            const [decodedLength, bn] = (value[0] & 0b11) < 0b11
                ? util.compactFromU8aLim(value)
                : util.compactFromU8a(value);
            return [new Type(registry, bn), decodedLength];
        }
        else if (value instanceof Compact) {
            const raw = value.unwrap();
            return raw instanceof Type
                ? [raw, 0]
                : [new Type(registry, raw), 0];
        }
        else if (value instanceof Type) {
            return [value, 0];
        }
        return [new Type(registry, value), 0];
    }
    class Compact {
        registry;
        createdAtHash;
        initialU8aLength;
        isStorageFallback;
        __internal__Type;
        __internal__raw;
        constructor(registry, Type, value = 0, { definition, setDefinition = util.identity } = {}) {
            this.registry = registry;
            this.__internal__Type = definition || setDefinition(typeToConstructor(registry, Type));
            const [raw, decodedLength] = decodeCompact(registry, this.__internal__Type, value);
            this.initialU8aLength = decodedLength;
            this.__internal__raw = raw;
        }
        static with(Type) {
            let definition;
            const setDefinition = (d) => (definition = d);
            return class extends Compact {
                constructor(registry, value) {
                    super(registry, Type, value, { definition, setDefinition });
                }
            };
        }
        get encodedLength() {
            return this.toU8a().length;
        }
        get hash() {
            return this.registry.hash(this.toU8a());
        }
        get isEmpty() {
            return this.__internal__raw.isEmpty;
        }
        bitLength() {
            return this.__internal__raw.bitLength();
        }
        eq(other) {
            return this.__internal__raw.eq(other instanceof Compact
                ? other.__internal__raw
                : other);
        }
        inspect() {
            return {
                outer: [this.toU8a()]
            };
        }
        toBigInt() {
            return this.__internal__raw.toBigInt();
        }
        toBn() {
            return this.__internal__raw.toBn();
        }
        toHex(isLe) {
            return this.__internal__raw.toHex(isLe);
        }
        toHuman(isExtended) {
            return this.__internal__raw.toHuman(isExtended);
        }
        toJSON() {
            return this.__internal__raw.toJSON();
        }
        toNumber() {
            return this.__internal__raw.toNumber();
        }
        toPrimitive() {
            return this.__internal__raw.toPrimitive();
        }
        toRawType() {
            return `Compact<${this.registry.getClassName(this.__internal__Type) || this.__internal__raw.toRawType()}>`;
        }
        toString() {
            return this.__internal__raw.toString();
        }
        toU8a(_isBare) {
            return util.compactToU8a(this.__internal__raw.toBn());
        }
        unwrap() {
            return this.__internal__raw;
        }
    }

    class DoNotConstruct {
        registry;
        createdAtHash;
        isStorageFallback;
        __internal__neverError;
        constructor(registry, typeName = 'DoNotConstruct') {
            this.registry = registry;
            this.__internal__neverError = new Error(`DoNotConstruct: Cannot construct unknown type ${typeName}`);
            throw this.__internal__neverError;
        }
        static with(typeName) {
            return class extends DoNotConstruct {
                constructor(registry) {
                    super(registry, typeName);
                }
            };
        }
        get encodedLength() {
            throw this.__internal__neverError;
        }
        get hash() {
            throw this.__internal__neverError;
        }
        get isEmpty() {
            throw this.__internal__neverError;
        }
        eq() {
            throw this.__internal__neverError;
        }
        inspect() {
            throw this.__internal__neverError;
        }
        toHex() {
            throw this.__internal__neverError;
        }
        toHuman() {
            throw this.__internal__neverError;
        }
        toJSON() {
            throw this.__internal__neverError;
        }
        toPrimitive() {
            throw this.__internal__neverError;
        }
        toRawType() {
            throw this.__internal__neverError;
        }
        toString() {
            throw this.__internal__neverError;
        }
        toU8a() {
            throw this.__internal__neverError;
        }
    }

    class Null {
        encodedLength = 0;
        isEmpty = true;
        registry;
        createdAtHash;
        initialU8aLength = 0;
        isStorageFallback;
        constructor(registry) {
            this.registry = registry;
        }
        get hash() {
            throw new Error('.hash is not implemented on Null');
        }
        eq(other) {
            return other instanceof Null || util.isNull(other);
        }
        inspect() {
            return {};
        }
        toHex() {
            return '0x';
        }
        toHuman() {
            return this.toJSON();
        }
        toJSON() {
            return null;
        }
        toPrimitive() {
            return null;
        }
        toRawType() {
            return 'Null';
        }
        toString() {
            return '';
        }
        toU8a(_isBare) {
            return new Uint8Array();
        }
    }

    function isRustEnum$1(def) {
        const defValues = Object.values(def);
        if (defValues.some((v) => util.isNumber(v))) {
            if (!defValues.every((v) => util.isNumber(v) && v >= 0 && v <= 255)) {
                throw new Error('Invalid number-indexed enum definition');
            }
            return false;
        }
        return true;
    }
    function extractDef(registry, _def) {
        const def = {};
        let isBasic;
        let isIndexed;
        if (Array.isArray(_def)) {
            for (let i = 0, count = _def.length; i < count; i++) {
                def[_def[i]] = { Type: Null, index: i };
            }
            isBasic = true;
            isIndexed = false;
        }
        else if (isRustEnum$1(_def)) {
            const [Types, keys] = mapToTypeMap(registry, _def);
            for (let i = 0, count = keys.length; i < count; i++) {
                def[keys[i]] = { Type: Types[i], index: i };
            }
            isBasic = !Object.values(def).some(({ Type }) => Type !== Null);
            isIndexed = false;
        }
        else {
            const entries = Object.entries(_def);
            for (let i = 0, count = entries.length; i < count; i++) {
                const [key, index] = entries[i];
                def[key] = { Type: Null, index };
            }
            isBasic = true;
            isIndexed = true;
        }
        return {
            def,
            isBasic,
            isIndexed
        };
    }
    function getEntryType(def, checkIdx) {
        const values = Object.values(def);
        for (let i = 0, count = values.length; i < count; i++) {
            const { Type, index } = values[i];
            if (index === checkIdx) {
                return Type;
            }
        }
        throw new Error(`Unable to create Enum via index ${checkIdx}, in ${Object.keys(def).join(', ')}`);
    }
    function createFromU8a(registry, def, index, value) {
        const Type = getEntryType(def, index);
        return {
            index,
            value: new Type(registry, value)
        };
    }
    function createFromValue(registry, def, index = 0, value) {
        const Type = getEntryType(def, index);
        return {
            index,
            value: value instanceof Type
                ? value
                : new Type(registry, value)
        };
    }
    function decodeFromJSON(registry, def, key, value) {
        const keys = Object.keys(def).map((k) => k.toLowerCase());
        const keyLower = key.toLowerCase();
        const index = keys.indexOf(keyLower);
        if (index === -1) {
            throw new Error(`Cannot map Enum JSON, unable to find '${key}' in ${keys.join(', ')}`);
        }
        try {
            return createFromValue(registry, def, Object.values(def)[index].index, value);
        }
        catch (error) {
            throw new Error(`Enum(${key}):: ${error.message}`);
        }
    }
    function decodeEnum(registry, def, value, index) {
        if (util.isNumber(index)) {
            return createFromValue(registry, def, index, value);
        }
        else if (util.isU8a(value) || util.isHex(value)) {
            const u8a = util.u8aToU8a(value);
            if (u8a.length) {
                return createFromU8a(registry, def, u8a[0], u8a.subarray(1));
            }
        }
        else if (value instanceof Enum) {
            return createFromValue(registry, def, value.index, value.value);
        }
        else if (util.isNumber(value)) {
            return createFromValue(registry, def, value);
        }
        else if (util.isString(value)) {
            return decodeFromJSON(registry, def, value.toString());
        }
        else if (util.isObject(value)) {
            const key = Object.keys(value)[0];
            return decodeFromJSON(registry, def, key, value[key]);
        }
        return createFromValue(registry, def, Object.values(def)[0].index);
    }
    class Enum {
        registry;
        createdAtHash;
        initialU8aLength;
        isStorageFallback;
        __internal__def;
        __internal__entryIndex;
        __internal__indexes;
        __internal__isBasic;
        __internal__isIndexed;
        __internal__raw;
        constructor(registry, Types, value, index, { definition, setDefinition = util.identity } = {}) {
            const { def, isBasic, isIndexed } = definition || setDefinition(extractDef(registry, Types));
            const decoded = util.isU8a(value) && value.length && !util.isNumber(index)
                ? createFromU8a(registry, def, value[0], value.subarray(1))
                : decodeEnum(registry, def, value, index);
            this.registry = registry;
            this.__internal__def = def;
            this.__internal__isBasic = isBasic;
            this.__internal__isIndexed = isIndexed;
            this.__internal__indexes = Object.values(def).map(({ index }) => index);
            this.__internal__entryIndex = this.__internal__indexes.indexOf(decoded.index);
            this.__internal__raw = decoded.value;
            if (this.__internal__raw.initialU8aLength) {
                this.initialU8aLength = 1 + this.__internal__raw.initialU8aLength;
            }
        }
        static with(Types) {
            let definition;
            const setDefinition = (d) => definition = d;
            return class extends Enum {
                static {
                    const keys = Array.isArray(Types)
                        ? Types
                        : Object.keys(Types);
                    const count = keys.length;
                    const asKeys = new Array(count);
                    const isKeys = new Array(count);
                    for (let i = 0; i < count; i++) {
                        const name = util.stringPascalCase(keys[i]);
                        asKeys[i] = `as${name}`;
                        isKeys[i] = `is${name}`;
                    }
                    util.objectProperties(this.prototype, isKeys, (_, i, self) => self.type === keys[i]);
                    util.objectProperties(this.prototype, asKeys, (k, i, self) => {
                        if (self.type !== keys[i]) {
                            throw new Error(`Cannot convert '${self.type}' via ${k}`);
                        }
                        return self.value;
                    });
                }
                constructor(registry, value, index) {
                    super(registry, Types, value, index, { definition, setDefinition });
                }
            };
        }
        get encodedLength() {
            return 1 + this.__internal__raw.encodedLength;
        }
        get hash() {
            return this.registry.hash(this.toU8a());
        }
        get index() {
            return this.__internal__indexes[this.__internal__entryIndex];
        }
        get inner() {
            return this.__internal__raw;
        }
        get isBasic() {
            return this.__internal__isBasic;
        }
        get isEmpty() {
            return this.__internal__raw.isEmpty;
        }
        get isNone() {
            return this.__internal__raw instanceof Null;
        }
        get defIndexes() {
            return this.__internal__indexes;
        }
        get defKeys() {
            return Object.keys(this.__internal__def);
        }
        get type() {
            return this.defKeys[this.__internal__entryIndex];
        }
        get value() {
            return this.__internal__raw;
        }
        eq(other) {
            if (util.isU8a(other)) {
                return !this.toU8a().some((entry, index) => entry !== other[index]);
            }
            else if (util.isNumber(other)) {
                return this.toNumber() === other;
            }
            else if (this.__internal__isBasic && util.isString(other)) {
                return this.type === other;
            }
            else if (util.isHex(other)) {
                return this.toHex() === other;
            }
            else if (other instanceof Enum) {
                return this.index === other.index && this.value.eq(other.value);
            }
            else if (util.isObject(other)) {
                return this.value.eq(other[this.type]);
            }
            return this.value.eq(other);
        }
        inspect() {
            if (this.__internal__isBasic) {
                return { outer: [new Uint8Array([this.index])] };
            }
            const { inner, outer = [] } = this.__internal__raw.inspect();
            return {
                inner,
                outer: [new Uint8Array([this.index]), ...outer]
            };
        }
        toHex() {
            return util.u8aToHex(this.toU8a());
        }
        toHuman(isExtended) {
            return this.__internal__isBasic || this.isNone
                ? this.type
                : { [this.type]: this.__internal__raw.toHuman(isExtended) };
        }
        toJSON() {
            return this.__internal__isBasic
                ? this.type
                : { [util.stringCamelCase(this.type)]: this.__internal__raw.toJSON() };
        }
        toNumber() {
            return this.index;
        }
        toPrimitive() {
            return this.__internal__isBasic
                ? this.type
                : { [util.stringCamelCase(this.type)]: this.__internal__raw.toPrimitive() };
        }
        _toRawStruct() {
            if (this.__internal__isBasic) {
                return this.__internal__isIndexed
                    ? this.defKeys.reduce((out, key, index) => {
                        out[key] = this.__internal__indexes[index];
                        return out;
                    }, {})
                    : this.defKeys;
            }
            const entries = Object.entries(this.__internal__def);
            return typesToMap(this.registry, entries.reduce((out, [key, { Type }], i) => {
                out[0][i] = Type;
                out[1][i] = key;
                return out;
            }, [new Array(entries.length), new Array(entries.length)]));
        }
        toRawType() {
            return util.stringify({ _enum: this._toRawStruct() });
        }
        toString() {
            return this.isNone
                ? this.type
                : util.stringify(this.toJSON());
        }
        toU8a(isBare) {
            return isBare
                ? this.__internal__raw.toU8a(isBare)
                : util.u8aConcatStrict([
                    new Uint8Array([this.index]),
                    this.__internal__raw.toU8a(isBare)
                ]);
        }
    }

    class Int extends AbstractInt {
        constructor(registry, value = 0, bitLength) {
            super(registry, value, bitLength, true);
        }
        static with(bitLength, typeName) {
            return class extends Int {
                constructor(registry, value) {
                    super(registry, value, bitLength);
                }
                toRawType() {
                    return typeName || super.toRawType();
                }
            };
        }
    }

    class None extends Null {
        toRawType() {
            return 'None';
        }
    }
    function decodeOption(registry, Type, value) {
        if (value instanceof Type) {
            return value;
        }
        else if (value instanceof Option) {
            if (value.value instanceof Type) {
                return value.value;
            }
            else if (value.isNone) {
                return new None(registry);
            }
            return new Type(registry, value.value);
        }
        else if (util.isNull(value) || util.isUndefined(value) || value === '0x' || value instanceof None) {
            return new None(registry);
        }
        else if (util.isU8a(value)) {
            return !value.length || value[0] === 0
                ? new None(registry)
                : new Type(registry, value.subarray(1));
        }
        return new Type(registry, value);
    }
    class Option {
        registry;
        createdAtHash;
        initialU8aLength;
        isStorageFallback;
        __internal__Type;
        __internal__raw;
        constructor(registry, typeName, value, { definition, setDefinition = util.identity } = {}) {
            const Type = definition || setDefinition(typeToConstructor(registry, typeName));
            const decoded = util.isU8a(value) && value.length && !util.isCodec(value)
                ? value[0] === 0
                    ? new None(registry)
                    : new Type(registry, value.subarray(1))
                : decodeOption(registry, Type, value);
            this.registry = registry;
            this.__internal__Type = Type;
            this.__internal__raw = decoded;
            if (decoded?.initialU8aLength) {
                this.initialU8aLength = 1 + decoded.initialU8aLength;
            }
        }
        static with(Type) {
            let definition;
            const setDefinition = (d) => {
                definition = d;
                return d;
            };
            return class extends Option {
                constructor(registry, value) {
                    super(registry, Type, value, { definition, setDefinition });
                }
            };
        }
        get encodedLength() {
            return 1 + this.__internal__raw.encodedLength;
        }
        get hash() {
            return this.registry.hash(this.toU8a());
        }
        get isEmpty() {
            return this.isNone;
        }
        get isNone() {
            return this.__internal__raw instanceof None;
        }
        get isSome() {
            return !this.isNone;
        }
        get value() {
            return this.__internal__raw;
        }
        eq(other) {
            if (other instanceof Option) {
                return (this.isSome === other.isSome) && this.value.eq(other.value);
            }
            return this.value.eq(other);
        }
        inspect() {
            if (this.isNone) {
                return { outer: [new Uint8Array([0])] };
            }
            const { inner, outer = [] } = this.__internal__raw.inspect();
            return {
                inner,
                outer: [new Uint8Array([1]), ...outer]
            };
        }
        toHex() {
            return this.isNone
                ? '0x'
                : util.u8aToHex(this.toU8a().subarray(1));
        }
        toHuman(isExtended) {
            return this.__internal__raw.toHuman(isExtended);
        }
        toJSON() {
            return this.isNone
                ? null
                : this.__internal__raw.toJSON();
        }
        toPrimitive() {
            return this.isNone
                ? null
                : this.__internal__raw.toPrimitive();
        }
        toRawType(isBare) {
            const wrapped = this.registry.getClassName(this.__internal__Type) || new this.__internal__Type(this.registry).toRawType();
            return isBare
                ? wrapped
                : `Option<${wrapped}>`;
        }
        toString() {
            return this.__internal__raw.toString();
        }
        toU8a(isBare) {
            if (isBare) {
                return this.__internal__raw.toU8a(true);
            }
            const u8a = new Uint8Array(this.encodedLength);
            if (this.isSome) {
                u8a.set([1]);
                u8a.set(this.__internal__raw.toU8a(), 1);
            }
            return u8a;
        }
        unwrap() {
            if (this.isNone) {
                throw new Error('Option: unwrapping a None value');
            }
            return this.__internal__raw;
        }
        unwrapOr(defaultValue) {
            return this.isSome
                ? this.unwrap()
                : defaultValue;
        }
        unwrapOrDefault() {
            return this.isSome
                ? this.unwrap()
                : new this.__internal__Type(this.registry);
        }
    }

    class Result extends Enum {
        constructor(registry, Ok, Err, value) {
            super(registry, { Ok, Err }, value);
        }
        static with(Types) {
            return class extends Result {
                constructor(registry, value) {
                    super(registry, Types.Ok, Types.Err, value);
                }
            };
        }
        get asErr() {
            if (!this.isErr) {
                throw new Error('Cannot extract Err value from Ok result, check isErr first');
            }
            return this.value;
        }
        get asOk() {
            if (!this.isOk) {
                throw new Error('Cannot extract Ok value from Err result, check isOk first');
            }
            return this.value;
        }
        get isEmpty() {
            return this.isOk && this.value.isEmpty;
        }
        get isErr() {
            return !this.isOk;
        }
        get isOk() {
            return this.index === 0;
        }
        toRawType() {
            const Types = this._toRawStruct();
            return `Result<${Types.Ok},${Types.Err}>`;
        }
    }

    function decodeTuple(registry, result, value, Classes) {
        if (Array.isArray(value)) {
            const Types = Classes[0];
            for (let i = 0, count = Types.length; i < count; i++) {
                try {
                    const entry = value?.[i];
                    result[i] = entry instanceof Types[i]
                        ? entry
                        : new Types[i](registry, entry);
                }
                catch (error) {
                    throw new Error(`Tuple: failed on ${i}:: ${error.message}`);
                }
            }
            return [result, 0];
        }
        else if (util.isHex(value)) {
            return decodeU8a$6(registry, result, util.u8aToU8a(value), Classes);
        }
        else if (!value || !result.length) {
            const Types = Classes[0];
            for (let i = 0, count = Types.length; i < count; i++) {
                result[i] = new Types[i](registry);
            }
            return [result, 0];
        }
        throw new Error(`Expected array input to Tuple decoding, found ${typeof value}: ${util.stringify(value)}`);
    }
    class Tuple extends AbstractArray {
        __internal__Types;
        constructor(registry, Types, value, { definition, setDefinition = util.identity } = {}) {
            const Classes = definition || setDefinition(Array.isArray(Types)
                ? [typesToConstructors(registry, Types), []]
                : util.isFunction(Types) || util.isString(Types)
                    ? [[typeToConstructor(registry, Types)], []]
                    : mapToTypeMap(registry, Types));
            super(registry, Classes[0].length);
            this.initialU8aLength = (util.isU8a(value)
                ? decodeU8a$6(registry, this, value, Classes)
                : decodeTuple(registry, this, value, Classes))[1];
            this.__internal__Types = Classes;
        }
        static with(Types) {
            let definition;
            const setDefinition = (d) => definition = d;
            return class extends Tuple {
                constructor(registry, value) {
                    super(registry, Types, value, { definition, setDefinition });
                }
            };
        }
        get encodedLength() {
            let total = 0;
            for (let i = 0, count = this.length; i < count; i++) {
                total += this[i].encodedLength;
            }
            return total;
        }
        get Types() {
            return this.__internal__Types[1].length
                ? this.__internal__Types[1]
                : this.__internal__Types[0].map((T) => new T(this.registry).toRawType());
        }
        inspect() {
            return {
                inner: this.inspectInner()
            };
        }
        toRawType() {
            const types = this.__internal__Types[0].map((T) => this.registry.getClassName(T) || new T(this.registry).toRawType());
            return `(${types.join(',')})`;
        }
        toString() {
            return util.stringify(this.toJSON());
        }
        toU8a(isBare) {
            return util.u8aConcatStrict(this.toU8aInner(isBare));
        }
    }

    class UInt extends AbstractInt {
        static with(bitLength, typeName) {
            return class extends UInt {
                constructor(registry, value) {
                    super(registry, value, bitLength);
                }
                toRawType() {
                    return typeName || super.toRawType();
                }
            };
        }
    }

    const MAX_LENGTH$2 = 64 * 1024;
    const l$5 = util.logger('Vec');
    function decodeVecLength(value) {
        if (Array.isArray(value)) {
            return [value, value.length, 0];
        }
        else if (util.isU8a(value) || util.isHex(value)) {
            const u8a = util.u8aToU8a(value);
            const [startAt, length] = util.compactFromU8aLim(u8a);
            if (length > MAX_LENGTH$2) {
                throw new Error(`Vec length ${length.toString()} exceeds ${MAX_LENGTH$2}`);
            }
            return [u8a, length, startAt];
        }
        else if (!value) {
            return [null, 0, 0];
        }
        throw new Error(`Expected array/hex input to Vec<*> decoding, found ${typeof value}: ${util.stringify(value)}`);
    }
    function decodeVec(registry, result, value, startAt, Type) {
        if (Array.isArray(value)) {
            const count = result.length;
            for (let i = 0; i < count; i++) {
                const entry = value[i];
                try {
                    result[i] = entry instanceof Type
                        ? entry
                        : new Type(registry, entry);
                }
                catch (error) {
                    l$5.error(`Unable to decode on index ${i}`, error.message);
                    throw error;
                }
            }
            return [0, 0];
        }
        else if (!value) {
            return [0, 0];
        }
        return decodeU8aVec(registry, result, util.u8aToU8a(value), startAt, Type);
    }
    class Vec extends AbstractArray {
        __internal__Type;
        constructor(registry, Type, value = [], { definition, setDefinition = util.identity } = {}) {
            const [decodeFrom, length, startAt] = decodeVecLength(value);
            super(registry, length);
            this.__internal__Type = definition || setDefinition(typeToConstructor(registry, Type));
            this.initialU8aLength = (util.isU8a(decodeFrom)
                ? decodeU8aVec(registry, this, decodeFrom, startAt, this.__internal__Type)
                : decodeVec(registry, this, decodeFrom, startAt, this.__internal__Type))[0];
        }
        static with(Type) {
            let definition;
            const setDefinition = (d) => (definition = d);
            return class extends Vec {
                constructor(registry, value) {
                    super(registry, Type, value, { definition, setDefinition });
                }
            };
        }
        get Type() {
            return this.__internal__Type.name;
        }
        indexOf(other) {
            const check = other instanceof this.__internal__Type
                ? other
                : new this.__internal__Type(this.registry, other);
            for (let i = 0, count = this.length; i < count; i++) {
                if (check.eq(this[i])) {
                    return i;
                }
            }
            return -1;
        }
        toRawType() {
            return `Vec<${this.registry.getClassName(this.__internal__Type) || new this.__internal__Type(this.registry).toRawType()}>`;
        }
    }

    class VecFixed extends AbstractArray {
        __internal__Type;
        constructor(registry, Type, length, value = [], { definition, setDefinition = util.identity } = {}) {
            super(registry, length);
            this.__internal__Type = definition || setDefinition(typeToConstructor(registry, Type));
            this.initialU8aLength = (util.isU8a(value)
                ? decodeU8aVec(registry, this, value, 0, this.__internal__Type)
                : decodeVec(registry, this, value, 0, this.__internal__Type))[1];
        }
        static with(Type, length) {
            let definition;
            const setDefinition = (d) => (definition = d);
            return class extends VecFixed {
                constructor(registry, value) {
                    super(registry, Type, length, value, { definition, setDefinition });
                }
            };
        }
        get Type() {
            return new this.__internal__Type(this.registry).toRawType();
        }
        get encodedLength() {
            let total = 0;
            for (let i = 0, count = this.length; i < count; i++) {
                total += this[i].encodedLength;
            }
            return total;
        }
        inspect() {
            return {
                inner: this.inspectInner()
            };
        }
        toU8a() {
            const encoded = this.toU8aInner();
            return encoded.length
                ? util.u8aConcatStrict(encoded)
                : new Uint8Array([]);
        }
        toRawType() {
            return `[${this.Type};${this.length}]`;
        }
    }

    class Raw extends Uint8Array {
        registry;
        createdAtHash;
        initialU8aLength;
        isStorageFallback;
        static get [Symbol.species]() {
            return Uint8Array;
        }
        constructor(registry, value, initialU8aLength) {
            super(util.u8aToU8a(value));
            this.registry = registry;
            this.initialU8aLength = initialU8aLength;
        }
        get encodedLength() {
            return this.length;
        }
        get hash() {
            return this.registry.hash(this.toU8a());
        }
        get isAscii() {
            return util.isAscii(this);
        }
        get isEmpty() {
            return !this.length || util.isUndefined(this.find((b) => !!b));
        }
        get isUtf8() {
            return util.isUtf8(this);
        }
        bitLength() {
            return this.length * 8;
        }
        eq(other) {
            if (other instanceof Uint8Array) {
                return (this.length === other.length) &&
                    !this.some((b, index) => b !== other[index]);
            }
            return this.eq(util.u8aToU8a(other));
        }
        inspect() {
            return {
                outer: [this.toU8a()]
            };
        }
        toHex() {
            return util.u8aToHex(this);
        }
        toHuman() {
            return this.toPrimitive();
        }
        toJSON() {
            return this.toHex();
        }
        toPrimitive() {
            if (this.isAscii) {
                const text = this.toUtf8();
                if (util.isAscii(text)) {
                    return text;
                }
            }
            return this.toJSON();
        }
        toRawType() {
            return 'Raw';
        }
        toString() {
            return this.toHex();
        }
        toU8a(_isBare) {
            return Uint8Array.from(this);
        }
        toUtf8() {
            if (!this.isUtf8) {
                throw new Error('The character sequence is not a valid Utf8 string');
            }
            return util.u8aToString(this);
        }
    }

    function decodeBitVecU8a(value) {
        if (!value?.length) {
            return [0, new Uint8Array()];
        }
        const [offset, length] = util.compactFromU8aLim(value);
        const total = offset + Math.ceil(length / 8);
        if (total > value.length) {
            throw new Error(`BitVec: required length less than remainder, expected at least ${total}, found ${value.length}`);
        }
        return [length, value.subarray(offset, total)];
    }
    function decodeBitVec(value) {
        if (Array.isArray(value) || util.isString(value)) {
            const u8a = util.u8aToU8a(value);
            return [u8a.length / 8, u8a];
        }
        return decodeBitVecU8a(value);
    }
    class BitVec extends Raw {
        __internal__decodedLength;
        __internal__isMsb;
        constructor(registry, value, isMsb = false) {
            const [decodedLength, u8a] = decodeBitVec(value);
            super(registry, u8a);
            this.__internal__decodedLength = decodedLength;
            this.__internal__isMsb = isMsb;
        }
        get encodedLength() {
            return this.length + util.compactToU8a(this.__internal__decodedLength).length;
        }
        inspect() {
            return {
                outer: [util.compactToU8a(this.__internal__decodedLength), super.toU8a()]
            };
        }
        toBoolArray() {
            const map = [...this.toU8a(true)].map((v) => [
                !!(v & 128),
                !!(v & 64),
                !!(v & 32),
                !!(v & 16),
                !!(v & 8),
                !!(v & 4),
                !!(v & 2),
                !!(v & 1)
            ]);
            const count = map.length;
            const result = new Array(8 * count);
            for (let i = 0; i < count; i++) {
                const off = i * 8;
                const v = map[i];
                for (let j = 0; j < 8; j++) {
                    result[off + j] = this.__internal__isMsb
                        ? v[j]
                        : v[7 - j];
                }
            }
            return result;
        }
        toHuman() {
            return `0b${[...this.toU8a(true)]
            .map((d) => `00000000${d.toString(2)}`.slice(-8))
            .map((s) => this.__internal__isMsb ? s : s.split('').reverse().join(''))
            .join('_')}`;
        }
        toRawType() {
            return 'BitVec';
        }
        toU8a(isBare) {
            const bitVec = super.toU8a(isBare);
            return isBare
                ? bitVec
                : util.u8aConcatStrict([util.compactToU8a(this.__internal__decodedLength), bitVec]);
        }
    }

    function noopSetDefinition(d) {
        return d;
    }
    function decodeStructFromObject(registry, [Types, keys], value, jsonMap) {
        let jsonObj;
        const typeofArray = Array.isArray(value);
        const typeofMap = value instanceof Map;
        const count = keys.length;
        if (!typeofArray && !typeofMap && !util.isObject(value)) {
            throw new Error(`Struct: Cannot decode value ${util.stringify(value)} (typeof ${typeof value}), expected an input object, map or array`);
        }
        else if (typeofArray && value.length !== count) {
            throw new Error(`Struct: Unable to map ${util.stringify(value)} array to object with known keys ${keys.join(', ')}`);
        }
        const raw = new Array(count);
        for (let i = 0; i < count; i++) {
            const key = keys[i];
            const jsonKey = jsonMap.get(key) || key;
            const Type = Types[i];
            let assign;
            try {
                if (typeofArray) {
                    assign = value[i];
                }
                else if (typeofMap) {
                    assign = jsonKey && value.get(jsonKey);
                }
                else {
                    assign = jsonKey && value[jsonKey];
                    if (util.isUndefined(assign)) {
                        if (util.isUndefined(jsonObj)) {
                            const entries = Object.entries(value);
                            jsonObj = {};
                            for (let e = 0, ecount = entries.length; e < ecount; e++) {
                                jsonObj[util.stringCamelCase(entries[e][0])] = entries[e][1];
                            }
                        }
                        assign = jsonKey && jsonObj[jsonKey];
                    }
                }
                raw[i] = [
                    key,
                    assign instanceof Type
                        ? assign
                        : new Type(registry, assign)
                ];
            }
            catch (error) {
                let type = Type.name;
                try {
                    type = new Type(registry).toRawType();
                }
                catch {
                }
                throw new Error(`Struct: failed on ${jsonKey}: ${type}:: ${error.message}`);
            }
        }
        return [raw, 0];
    }
    class Struct extends Map {
        registry;
        createdAtHash;
        initialU8aLength;
        isStorageFallback;
        __internal__jsonMap;
        __internal__Types;
        constructor(registry, Types, value, jsonMap = new Map(), { definition, setDefinition = noopSetDefinition } = {}) {
            const typeMap = definition || setDefinition(mapToTypeMap(registry, Types));
            const [decoded, decodedLength] = util.isU8a(value) || util.isHex(value)
                ? decodeU8aStruct(registry, new Array(typeMap[0].length), util.u8aToU8a(value), typeMap)
                : value instanceof Struct
                    ? [value, 0]
                    : decodeStructFromObject(registry, typeMap, value || {}, jsonMap);
            super(decoded);
            this.initialU8aLength = decodedLength;
            this.registry = registry;
            this.__internal__jsonMap = jsonMap;
            this.__internal__Types = typeMap;
        }
        static with(Types, jsonMap) {
            let definition;
            const setDefinition = (d) => definition = d;
            return class extends Struct {
                static {
                    const keys = Object.keys(Types);
                    util.objectProperties(this.prototype, keys, (k, _, self) => self.get(k));
                }
                constructor(registry, value) {
                    super(registry, Types, value, jsonMap, { definition, setDefinition });
                }
            };
        }
        get defKeys() {
            return this.__internal__Types[1];
        }
        get isEmpty() {
            for (const v of this.values()) {
                if (!v.isEmpty) {
                    return false;
                }
            }
            return true;
        }
        get encodedLength() {
            let total = 0;
            for (const v of this.values()) {
                total += v.encodedLength;
            }
            return total;
        }
        get hash() {
            return this.registry.hash(this.toU8a());
        }
        get Type() {
            const result = {};
            const [Types, keys] = this.__internal__Types;
            for (let i = 0, count = keys.length; i < count; i++) {
                result[keys[i]] = new Types[i](this.registry).toRawType();
            }
            return result;
        }
        eq(other) {
            return compareMap(this, other);
        }
        get(key) {
            return super.get(key);
        }
        getAtIndex(index) {
            return this.toArray()[index];
        }
        getT(key) {
            return super.get(key);
        }
        inspect(isBare) {
            const inner = [];
            for (const [k, v] of this.entries()) {
                inner.push({
                    ...v.inspect(!isBare || util.isBoolean(isBare)
                        ? isBare
                        : isBare[k]),
                    name: util.stringCamelCase(k)
                });
            }
            return {
                inner
            };
        }
        toArray() {
            return [...this.values()];
        }
        toHex() {
            return util.u8aToHex(this.toU8a());
        }
        toHuman(isExtended) {
            const json = {};
            for (const [k, v] of this.entries()) {
                json[k] = v.toHuman(isExtended);
            }
            return json;
        }
        toJSON() {
            const json = {};
            for (const [k, v] of this.entries()) {
                json[(this.__internal__jsonMap.get(k) || k)] = v.toJSON();
            }
            return json;
        }
        toPrimitive() {
            const json = {};
            for (const [k, v] of this.entries()) {
                json[k] = v.toPrimitive();
            }
            return json;
        }
        toRawType() {
            return util.stringify(typesToMap(this.registry, this.__internal__Types));
        }
        toString() {
            return util.stringify(this.toJSON());
        }
        toU8a(isBare) {
            const encoded = [];
            for (const [k, v] of this.entries()) {
                encoded.push(v.toU8a(!isBare || util.isBoolean(isBare)
                    ? isBare
                    : isBare[k]));
            }
            return util.u8aConcatStrict(encoded);
        }
    }

    const l$4 = util.logger('Map');
    function decodeMapFromU8a(registry, KeyClass, ValClass, u8a) {
        const output = new Map();
        const [offset, count] = util.compactFromU8aLim(u8a);
        const types = [];
        for (let i = 0; i < count; i++) {
            types.push(KeyClass, ValClass);
        }
        const [values, decodedLength] = decodeU8a$6(registry, new Array(types.length), u8a.subarray(offset), [types, []]);
        for (let i = 0, count = values.length; i < count; i += 2) {
            output.set(values[i], values[i + 1]);
        }
        return [KeyClass, ValClass, output, offset + decodedLength];
    }
    function decodeMapFromMap(registry, KeyClass, ValClass, value) {
        const output = new Map();
        for (const [key, val] of value.entries()) {
            const isComplex = KeyClass.prototype instanceof AbstractArray ||
                KeyClass.prototype instanceof Struct ||
                KeyClass.prototype instanceof Enum;
            try {
                output.set(key instanceof KeyClass
                    ? key
                    : new KeyClass(registry, isComplex && typeof key === 'string' ? JSON.parse(key) : key), val instanceof ValClass
                    ? val
                    : new ValClass(registry, val));
            }
            catch (error) {
                l$4.error('Failed to decode key or value:', error.message);
                throw error;
            }
        }
        return [KeyClass, ValClass, output, 0];
    }
    function decodeMap(registry, keyType, valType, value) {
        const KeyClass = typeToConstructor(registry, keyType);
        const ValClass = typeToConstructor(registry, valType);
        if (!value) {
            return [KeyClass, ValClass, new Map(), 0];
        }
        else if (util.isU8a(value) || util.isHex(value)) {
            return decodeMapFromU8a(registry, KeyClass, ValClass, util.u8aToU8a(value));
        }
        else if (value instanceof Map) {
            return decodeMapFromMap(registry, KeyClass, ValClass, value);
        }
        else if (util.isObject(value)) {
            return decodeMapFromMap(registry, KeyClass, ValClass, new Map(Object.entries(value)));
        }
        throw new Error('Map: cannot decode type');
    }
    class CodecMap extends Map {
        registry;
        createdAtHash;
        initialU8aLength;
        isStorageFallback;
        __internal__KeyClass;
        __internal__ValClass;
        __internal__type;
        constructor(registry, keyType, valType, rawValue, type = 'HashMap') {
            const [KeyClass, ValClass, decoded, decodedLength] = decodeMap(registry, keyType, valType, rawValue);
            super(type === 'BTreeMap' ? sortMap(decoded) : decoded);
            this.registry = registry;
            this.initialU8aLength = decodedLength;
            this.__internal__KeyClass = KeyClass;
            this.__internal__ValClass = ValClass;
            this.__internal__type = type;
        }
        get encodedLength() {
            let len = util.compactToU8a(this.size).length;
            for (const [k, v] of this.entries()) {
                len += k.encodedLength + v.encodedLength;
            }
            return len;
        }
        get hash() {
            return this.registry.hash(this.toU8a());
        }
        get isEmpty() {
            return this.size === 0;
        }
        eq(other) {
            return compareMap(this, other);
        }
        inspect() {
            const inner = [];
            for (const [k, v] of this.entries()) {
                inner.push(k.inspect());
                inner.push(v.inspect());
            }
            return {
                inner,
                outer: [util.compactToU8a(this.size)]
            };
        }
        toHex() {
            return util.u8aToHex(this.toU8a());
        }
        toHuman(isExtended) {
            const json = {};
            for (const [k, v] of this.entries()) {
                json[k instanceof Raw && k.isAscii
                    ? k.toUtf8()
                    : k.toString()] = v.toHuman(isExtended);
            }
            return json;
        }
        toJSON() {
            const json = {};
            for (const [k, v] of this.entries()) {
                json[k.toString()] = v.toJSON();
            }
            return json;
        }
        toPrimitive() {
            const json = {};
            for (const [k, v] of this.entries()) {
                json[k instanceof Raw && k.isAscii
                    ? k.toUtf8()
                    : k.toString()] = v.toPrimitive();
            }
            return json;
        }
        toRawType() {
            return `${this.__internal__type}<${this.registry.getClassName(this.__internal__KeyClass) || new this.__internal__KeyClass(this.registry).toRawType()},${this.registry.getClassName(this.__internal__ValClass) || new this.__internal__ValClass(this.registry).toRawType()}>`;
        }
        toString() {
            return util.stringify(this.toJSON());
        }
        toU8a(isBare) {
            const encoded = [];
            if (!isBare) {
                encoded.push(util.compactToU8a(this.size));
            }
            for (const [k, v] of this.entries()) {
                encoded.push(k.toU8a(isBare), v.toU8a(isBare));
            }
            return util.u8aConcatStrict(encoded);
        }
    }

    class BTreeMap extends CodecMap {
        static with(keyType, valType) {
            return class extends BTreeMap {
                constructor(registry, value) {
                    super(registry, keyType, valType, value, 'BTreeMap');
                }
            };
        }
    }

    const l$3 = util.logger('BTreeSet');
    function decodeSetFromU8a(registry, ValClass, u8a) {
        const output = new Set();
        const [offset, count] = util.compactFromU8aLim(u8a);
        const result = new Array(count);
        const [decodedLength] = decodeU8aVec(registry, result, u8a, offset, ValClass);
        for (let i = 0; i < count; i++) {
            output.add(result[i]);
        }
        return [ValClass, output, decodedLength];
    }
    function decodeSetFromSet(registry, ValClass, value) {
        const output = new Set();
        value.forEach((val) => {
            try {
                output.add((val instanceof ValClass) ? val : new ValClass(registry, val));
            }
            catch (error) {
                l$3.error('Failed to decode key or value:', error.message);
                throw error;
            }
        });
        return [ValClass, output, 0];
    }
    function decodeSet$1(registry, valType, value) {
        const ValClass = typeToConstructor(registry, valType);
        if (!value) {
            return [ValClass, new Set(), 0];
        }
        else if (util.isU8a(value) || util.isHex(value)) {
            return decodeSetFromU8a(registry, ValClass, util.u8aToU8a(value));
        }
        else if (Array.isArray(value) || value instanceof Set) {
            return decodeSetFromSet(registry, ValClass, value);
        }
        throw new Error('BTreeSet: cannot decode type');
    }
    class BTreeSet extends Set {
        registry;
        createdAtHash;
        initialU8aLength;
        isStorageFallback;
        __internal__ValClass;
        constructor(registry, valType, rawValue) {
            const [ValClass, values, decodedLength] = decodeSet$1(registry, valType, rawValue);
            super(sortSet(values));
            this.registry = registry;
            this.initialU8aLength = decodedLength;
            this.__internal__ValClass = ValClass;
        }
        static with(valType) {
            return class extends BTreeSet {
                constructor(registry, value) {
                    super(registry, valType, value);
                }
            };
        }
        get encodedLength() {
            let len = util.compactToU8a(this.size).length;
            for (const v of this.values()) {
                len += v.encodedLength;
            }
            return len;
        }
        get hash() {
            return this.registry.hash(this.toU8a());
        }
        get isEmpty() {
            return this.size === 0;
        }
        get strings() {
            return [...super.values()].map((v) => v.toString());
        }
        eq(other) {
            return compareSet(this, other);
        }
        inspect() {
            const inner = [];
            for (const v of this.values()) {
                inner.push(v.inspect());
            }
            return {
                inner,
                outer: [util.compactToU8a(this.size)]
            };
        }
        toHex() {
            return util.u8aToHex(this.toU8a());
        }
        toHuman(isExtended) {
            const json = [];
            for (const v of this.values()) {
                json.push(v.toHuman(isExtended));
            }
            return json;
        }
        toJSON() {
            const json = [];
            for (const v of this.values()) {
                json.push(v.toJSON());
            }
            return json;
        }
        toRawType() {
            return `BTreeSet<${this.registry.getClassName(this.__internal__ValClass) || new this.__internal__ValClass(this.registry).toRawType()}>`;
        }
        toPrimitive() {
            const json = [];
            for (const v of this.values()) {
                json.push(v.toPrimitive());
            }
            return json;
        }
        toString() {
            return util.stringify(this.toJSON());
        }
        toU8a(isBare) {
            const encoded = [];
            if (!isBare) {
                encoded.push(util.compactToU8a(this.size));
            }
            for (const v of this.values()) {
                encoded.push(v.toU8a(isBare));
            }
            return util.u8aConcatStrict(encoded);
        }
    }

    const MAX_LENGTH$1 = 10 * 1024 * 1024;
    function decodeBytesU8a(value) {
        if (!value.length) {
            return [new Uint8Array(), 0];
        }
        const [offset, length] = util.compactFromU8aLim(value);
        const total = offset + length;
        if (length > MAX_LENGTH$1) {
            throw new Error(`Bytes length ${length.toString()} exceeds ${MAX_LENGTH$1}`);
        }
        else if (total > value.length) {
            throw new Error(`Bytes: required length less than remainder, expected at least ${total}, found ${value.length}`);
        }
        return [value.subarray(offset, total), total];
    }
    class Bytes extends Raw {
        constructor(registry, value) {
            const [u8a, decodedLength] = util.isU8a(value) && !(value instanceof Raw)
                ? decodeBytesU8a(value)
                : Array.isArray(value) || util.isString(value)
                    ? [util.u8aToU8a(value), 0]
                    : [value, 0];
            super(registry, u8a, decodedLength);
        }
        get encodedLength() {
            return this.length + util.compactToU8a(this.length).length;
        }
        inspect(isBare) {
            const clength = util.compactToU8a(this.length);
            return {
                outer: isBare
                    ? [super.toU8a()]
                    : this.length
                        ? [clength, super.toU8a()]
                        : [clength]
            };
        }
        toRawType() {
            return 'Bytes';
        }
        toU8a(isBare) {
            return isBare
                ? super.toU8a(isBare)
                : util.compactAddLength(this);
        }
    }

    class HashMap extends CodecMap {
        static with(keyType, valType) {
            return class extends HashMap {
                constructor(registry, value) {
                    super(registry, keyType, valType, value);
                }
            };
        }
    }

    const EMPTY = new Uint8Array();
    class Linkage extends Struct {
        constructor(registry, Type, value) {
            super(registry, {
                previous: Option.with(Type),
                next: Option.with(Type)
            }, value);
        }
        static withKey(Type) {
            return class extends Linkage {
                constructor(registry, value) {
                    super(registry, Type, value);
                }
            };
        }
        get previous() {
            return this.get('previous');
        }
        get next() {
            return this.get('next');
        }
        toRawType() {
            return `Linkage<${this.next.toRawType(true)}>`;
        }
        toU8a(isBare) {
            return this.isEmpty
                ? EMPTY
                : super.toU8a(isBare);
        }
    }

    class bool extends Boolean {
        registry;
        createdAtHash;
        initialU8aLength = 1;
        isStorageFallback;
        constructor(registry, value = false) {
            super(util.isU8a(value)
                ? value[0] === 1
                : value instanceof Boolean
                    ? value.valueOf()
                    : !!value);
            this.registry = registry;
        }
        get encodedLength() {
            return 1 | 0;
        }
        get hash() {
            return this.registry.hash(this.toU8a());
        }
        get isEmpty() {
            return this.isFalse;
        }
        get isFalse() {
            return !this.isTrue;
        }
        get isTrue() {
            return this.valueOf();
        }
        eq(other) {
            return this.valueOf() === (other instanceof Boolean
                ? other.valueOf()
                : other);
        }
        inspect() {
            return {
                outer: [this.toU8a()]
            };
        }
        toHex() {
            return util.u8aToHex(this.toU8a());
        }
        toHuman() {
            return this.toJSON();
        }
        toJSON() {
            return this.valueOf();
        }
        toPrimitive() {
            return this.toJSON();
        }
        toRawType() {
            return 'bool';
        }
        toString() {
            return this.toJSON().toString();
        }
        toU8a(_isBare) {
            return new Uint8Array([this.valueOf() ? 1 : 0]);
        }
    }

    function decodeU8a$5(registry, value) {
        return value[0] === 0
            ? null
            : new bool(registry, value[0] === 1);
    }
    class OptionBool extends Option {
        constructor(registry, value) {
            super(registry, bool, util.isU8a(value) || util.isHex(value)
                ? decodeU8a$5(registry, util.u8aToU8a(value))
                : value);
            this.initialU8aLength = 1;
        }
        get encodedLength() {
            return 1 | 0;
        }
        get isFalse() {
            return this.isSome
                ? !this.value.valueOf()
                : false;
        }
        get isTrue() {
            return this.isSome
                ? this.value.valueOf()
                : false;
        }
        inspect() {
            return { outer: [this.toU8a()] };
        }
        toRawType(isBare) {
            return isBare
                ? 'bool'
                : 'Option<bool>';
        }
        toU8a(isBare) {
            if (isBare) {
                return super.toU8a(true);
            }
            return this.isSome
                ? new Uint8Array([this.isTrue ? 1 : 2])
                : new Uint8Array([0]);
        }
    }

    class Range extends Tuple {
        __internal__rangeName;
        constructor(registry, Type, value, { rangeName = 'Range' } = {}) {
            super(registry, [Type, Type], value);
            this.__internal__rangeName = rangeName;
        }
        static with(Type) {
            return class extends Range {
                constructor(registry, value) {
                    super(registry, Type, value);
                }
            };
        }
        get start() {
            return this[0];
        }
        get end() {
            return this[1];
        }
        toRawType() {
            return `${this.__internal__rangeName}<${this.start.toRawType()}>`;
        }
    }

    class RangeInclusive extends Range {
        constructor(registry, Type, value) {
            super(registry, Type, value, { rangeName: 'RangeInclusive' });
        }
        static with(Type) {
            return class extends RangeInclusive {
                constructor(registry, value) {
                    super(registry, Type, value);
                }
            };
        }
    }

    const MAX_LENGTH = 128 * 1024;
    function decodeText(value) {
        if (util.isU8a(value)) {
            if (!value.length) {
                return ['', 0];
            }
            if (value instanceof Raw) {
                return [util.u8aToString(value), 0];
            }
            const [offset, length] = util.compactFromU8aLim(value);
            const total = offset + length;
            if (length > MAX_LENGTH) {
                throw new Error(`Text: length ${length.toString()} exceeds ${MAX_LENGTH}`);
            }
            else if (total > value.length) {
                throw new Error(`Text: required length less than remainder, expected at least ${total}, found ${value.length}`);
            }
            return [util.u8aToString(value.subarray(offset, total)), total];
        }
        else if (util.isHex(value)) {
            return [util.u8aToString(util.hexToU8a(value)), 0];
        }
        return [value ? value.toString() : '', 0];
    }
    class Text extends String {
        registry;
        createdAtHash;
        initialU8aLength;
        isStorageFallback;
        __internal__override = null;
        constructor(registry, value) {
            const [str, decodedLength] = decodeText(value);
            super(str);
            this.registry = registry;
            this.initialU8aLength = decodedLength;
        }
        get encodedLength() {
            return this.toU8a().length;
        }
        get hash() {
            return this.registry.hash(this.toU8a());
        }
        get isEmpty() {
            return this.length === 0;
        }
        get length() {
            return super.length;
        }
        eq(other) {
            return util.isString(other)
                ? this.toString() === other.toString()
                : false;
        }
        inspect() {
            const value = util.stringToU8a(super.toString());
            return {
                outer: value.length
                    ? [util.compactToU8a(value.length), value]
                    : [util.compactToU8a(value.length)]
            };
        }
        setOverride(override) {
            this.__internal__override = override;
        }
        toHex() {
            return util.u8aToHex(this.toU8a(true));
        }
        toHuman() {
            return this.toJSON();
        }
        toJSON() {
            return this.toString();
        }
        toPrimitive() {
            return this.toJSON();
        }
        toRawType() {
            return 'Text';
        }
        toString() {
            return this.__internal__override || super.toString();
        }
        toU8a(isBare) {
            const encoded = util.stringToU8a(super.toString());
            return isBare
                ? encoded
                : util.compactAddLength(encoded);
        }
    }

    class Type extends Text {
        constructor(registry, value = '') {
            super(registry, value);
            this.setOverride(sanitize(this.toString()));
        }
        toRawType() {
            return 'Type';
        }
    }

    function decodeU8aFixed(value, bitLength) {
        const u8a = util.u8aToU8a(value);
        const byteLength = bitLength / 8;
        if (!u8a.length) {
            return [new Uint8Array(byteLength), 0];
        }
        if (util.isU8a(value) ? u8a.length < byteLength : u8a.length !== byteLength) {
            throw new Error(`Expected input with ${byteLength} bytes (${bitLength} bits), found ${u8a.length} bytes`);
        }
        return [u8a.subarray(0, byteLength), byteLength];
    }
    class U8aFixed extends Raw {
        constructor(registry, value = new Uint8Array(), bitLength = 256) {
            const [u8a, decodedLength] = decodeU8aFixed(value, bitLength);
            super(registry, u8a, decodedLength);
        }
        static with(bitLength, typeName) {
            return class extends U8aFixed {
                constructor(registry, value) {
                    super(registry, value, bitLength);
                }
                toRawType() {
                    return typeName || super.toRawType();
                }
            };
        }
        toRawType() {
            return `[u8;${this.length}]`;
        }
    }

    function decodeRaw(registry, typeName, value) {
        const Type = typeToConstructor(registry, typeName);
        if (util.isU8a(value) || util.isHex(value)) {
            try {
                const [, u8a] = util.isHex(value)
                    ? [0, util.u8aToU8a(value)]
                    : (value instanceof Raw)
                        ? [0, value.subarray()]
                        : util.compactStripLength(value);
                return [Type, new Type(registry, u8a), value];
            }
            catch {
                return [Type, null, value];
            }
        }
        const instance = new Type(registry, value);
        return [Type, instance, util.compactAddLength(instance.toU8a())];
    }
    class WrapperKeepOpaque extends Bytes {
        __internal__Type;
        __internal__decoded;
        __internal__opaqueName;
        constructor(registry, typeName, value, { opaqueName = 'WrapperKeepOpaque' } = {}) {
            const [Type, decoded, u8a] = decodeRaw(registry, typeName, value);
            super(registry, u8a);
            this.__internal__Type = Type;
            this.__internal__decoded = decoded;
            this.__internal__opaqueName = opaqueName;
        }
        static with(Type) {
            return class extends WrapperKeepOpaque {
                constructor(registry, value) {
                    super(registry, Type, value);
                }
            };
        }
        get isDecoded() {
            return !!this.__internal__decoded;
        }
        inspect() {
            return this.__internal__decoded
                ? {
                    inner: [this.__internal__decoded.inspect()],
                    outer: [util.compactToU8a(this.length)]
                }
                : {
                    outer: [util.compactToU8a(this.length), this.toU8a(true)]
                };
        }
        toHuman(isExtended) {
            return this.__internal__decoded
                ? this.__internal__decoded.toHuman(isExtended)
                : super.toHuman();
        }
        toPrimitive() {
            return this.__internal__decoded
                ? this.__internal__decoded.toPrimitive()
                : super.toPrimitive();
        }
        toRawType() {
            return `${this.__internal__opaqueName}<${this.registry.getClassName(this.__internal__Type) || (this.__internal__decoded ? this.__internal__decoded.toRawType() : new this.__internal__Type(this.registry).toRawType())}>`;
        }
        toString() {
            return this.__internal__decoded
                ? this.__internal__decoded.toString()
                : super.toString();
        }
        unwrap() {
            if (!this.__internal__decoded) {
                throw new Error(`${this.__internal__opaqueName}: unwrapping an undecodable value`);
            }
            return this.__internal__decoded;
        }
    }

    class WrapperOpaque extends WrapperKeepOpaque {
        constructor(registry, typeName, value) {
            super(registry, typeName, value, { opaqueName: 'WrapperOpaque' });
        }
        static with(Type) {
            return class extends WrapperOpaque {
                constructor(registry, value) {
                    super(registry, Type, value);
                }
            };
        }
        get inner() {
            return this.unwrap();
        }
    }

    class Float extends Number {
        encodedLength;
        registry;
        createdAtHash;
        initialU8aLength;
        isStorageFallback;
        __internal__bitLength;
        constructor(registry, value, { bitLength = 32 } = {}) {
            super(util.isU8a(value) || util.isHex(value)
                ? value.length === 0
                    ? 0
                    : util.u8aToFloat(util.u8aToU8a(value), { bitLength })
                : (value || 0));
            this.__internal__bitLength = bitLength;
            this.encodedLength = bitLength / 8;
            this.initialU8aLength = this.encodedLength;
            this.registry = registry;
        }
        static with(bitLength) {
            return class extends Float {
                constructor(registry, value) {
                    super(registry, value, { bitLength });
                }
            };
        }
        get hash() {
            return this.registry.hash(this.toU8a());
        }
        get isEmpty() {
            return this.valueOf() === 0;
        }
        eq(other) {
            return this.valueOf() === Number(other);
        }
        inspect() {
            return {
                outer: [this.toU8a()]
            };
        }
        toHex() {
            return util.u8aToHex(this.toU8a());
        }
        toHuman() {
            return this.toString();
        }
        toJSON() {
            return this.toHex();
        }
        toNumber() {
            return this.valueOf();
        }
        toPrimitive() {
            return this.toNumber();
        }
        toRawType() {
            return `f${this.__internal__bitLength}`;
        }
        toU8a(_isBare) {
            return util.floatToU8a(this, {
                bitLength: this.__internal__bitLength
            });
        }
    }

    function decodeJson(value) {
        return Object.entries(value || {});
    }
    class Json extends Map {
        registry;
        createdAtHash;
        initialU8aLength;
        isStorageFallback;
        constructor(registry, value) {
            const decoded = decodeJson(value);
            super(decoded);
            this.registry = registry;
            util.objectProperties(this, decoded.map(([k]) => k), (k) => this.get(k));
        }
        get encodedLength() {
            return 0 | 0;
        }
        get hash() {
            return this.registry.hash(this.toU8a());
        }
        get isEmpty() {
            return [...this.keys()].length === 0;
        }
        eq(other) {
            return compareMap(this, other);
        }
        getT(key) {
            return this.get(key);
        }
        inspect() {
            throw new Error('Unimplemented');
        }
        toHex() {
            throw new Error('Unimplemented');
        }
        toHuman() {
            return [...this.entries()].reduce((json, [key, value]) => {
                json[key] = util.isFunction(value.toHuman)
                    ? value.toHuman()
                    : value;
                return json;
            }, {});
        }
        toJSON() {
            return [...this.entries()].reduce((json, [key, value]) => {
                json[key] = value;
                return json;
            }, {});
        }
        toPrimitive() {
            return [...this.entries()].reduce((json, [key, value]) => {
                json[key] = util.isFunction(value.toPrimitive)
                    ? value.toPrimitive()
                    : value;
                return json;
            }, {});
        }
        toRawType() {
            return 'Json';
        }
        toString() {
            return util.stringify(this.toJSON());
        }
        toU8a(_isBare) {
            throw new Error('Unimplemented');
        }
    }

    function encodeSet(setValues, values) {
        const encoded = new util.BN(0);
        for (let i = 0, count = values.length; i < count; i++) {
            encoded.ior(util.bnToBn(setValues[values[i]] || 0));
        }
        return encoded;
    }
    function decodeSetArray(setValues, values) {
        const count = values.length;
        const result = new Array(count);
        for (let i = 0; i < count; i++) {
            const key = values[i];
            if (util.isUndefined(setValues[key])) {
                throw new Error(`Set: Invalid key '${key}' passed to Set, allowed ${Object.keys(setValues).join(', ')}`);
            }
            result[i] = key;
        }
        return result;
    }
    function decodeSetNumber(setValues, _value) {
        const bn = util.bnToBn(_value);
        const keys = Object.keys(setValues);
        const result = [];
        for (let i = 0, count = keys.length; i < count; i++) {
            const key = keys[i];
            if (bn.and(util.bnToBn(setValues[key])).eq(util.bnToBn(setValues[key]))) {
                result.push(key);
            }
        }
        const computed = encodeSet(setValues, result);
        if (!bn.eq(computed)) {
            throw new Error(`Set: Mismatch decoding '${bn.toString()}', computed as '${computed.toString()}' with ${result.join(', ')}`);
        }
        return result;
    }
    function decodeSet(setValues, value = 0, bitLength) {
        if (bitLength % 8 !== 0) {
            throw new Error(`Expected valid bitLength, power of 8, found ${bitLength}`);
        }
        const byteLength = bitLength / 8;
        if (util.isU8a(value)) {
            return value.length === 0
                ? []
                : decodeSetNumber(setValues, util.u8aToBn(value.subarray(0, byteLength), { isLe: true }));
        }
        else if (util.isString(value)) {
            return decodeSet(setValues, util.u8aToU8a(value), byteLength);
        }
        else if (value instanceof Set || Array.isArray(value)) {
            const input = Array.isArray(value)
                ? value
                : [...value.values()];
            return decodeSetArray(setValues, input);
        }
        return decodeSetNumber(setValues, value);
    }
    class CodecSet extends Set {
        registry;
        createdAtHash;
        initialU8aLength;
        isStorageFallback;
        __internal__allowed;
        __internal__byteLength;
        constructor(registry, setValues, value, bitLength = 8) {
            super(decodeSet(setValues, value, bitLength));
            this.registry = registry;
            this.__internal__allowed = setValues;
            this.__internal__byteLength = bitLength / 8;
        }
        static with(values, bitLength) {
            return class extends CodecSet {
                static {
                    const keys = Object.keys(values);
                    const count = keys.length;
                    const isKeys = new Array(count);
                    for (let i = 0; i < count; i++) {
                        isKeys[i] = `is${util.stringPascalCase(keys[i])}`;
                    }
                    util.objectProperties(this.prototype, isKeys, (_, i, self) => self.strings.includes(keys[i]));
                }
                constructor(registry, value) {
                    super(registry, values, value, bitLength);
                }
            };
        }
        get encodedLength() {
            return this.__internal__byteLength;
        }
        get hash() {
            return this.registry.hash(this.toU8a());
        }
        get isEmpty() {
            return this.size === 0;
        }
        get strings() {
            return [...super.values()];
        }
        get valueEncoded() {
            return encodeSet(this.__internal__allowed, this.strings);
        }
        add = (key) => {
            if (this.__internal__allowed && util.isUndefined(this.__internal__allowed[key])) {
                throw new Error(`Set: Invalid key '${key}' on add`);
            }
            super.add(key);
            return this;
        };
        eq(other) {
            if (Array.isArray(other)) {
                return compareArray(this.strings.sort(), other.sort());
            }
            else if (other instanceof Set) {
                return this.eq([...other.values()]);
            }
            else if (util.isNumber(other) || util.isBn(other)) {
                return this.valueEncoded.eq(util.bnToBn(other));
            }
            return false;
        }
        inspect() {
            return {
                outer: [this.toU8a()]
            };
        }
        toHex() {
            return util.u8aToHex(this.toU8a());
        }
        toHuman() {
            return this.toJSON();
        }
        toJSON() {
            return this.strings;
        }
        toNumber() {
            return this.valueEncoded.toNumber();
        }
        toPrimitive() {
            return this.toJSON();
        }
        toRawType() {
            return util.stringify({ _set: this.__internal__allowed });
        }
        toString() {
            return `[${this.strings.join(', ')}]`;
        }
        toU8a(_isBare) {
            return util.bnToU8a(this.valueEncoded, {
                bitLength: this.__internal__byteLength * 8,
                isLe: true
            });
        }
    }

    class f32 extends Float.with(32) {
        __FloatType = 'f32';
    }

    class f64 extends Float.with(64) {
        __FloatType = 'f64';
    }

    class i8 extends Int.with(8) {
        __IntType = 'i8';
    }

    class i16 extends Int.with(16) {
        __IntType = 'i16';
    }

    class i32 extends Int.with(32) {
        __IntType = 'i32';
    }

    class i64 extends Int.with(64) {
        __IntType = 'i64';
    }

    class i128 extends Int.with(128) {
        __IntType = 'i128';
    }

    class i256 extends Int.with(256) {
        __IntType = 'i256';
    }

    class isize extends i32 {
        constructor(registry, value) {
            super(registry, value);
            throw new Error('The `isize` type should not be used. Since it is platform-specific, it creates incompatibilities between native (generally i64) and WASM (always i32) code. Use one of the `i32` or `i64` types explicitly.');
        }
    }

    class u8 extends UInt.with(8) {
        __UIntType = 'u8';
    }

    class u16 extends UInt.with(16) {
        __UIntType = 'u16';
    }

    class u32 extends UInt.with(32) {
        __UIntType = 'u32';
    }

    class u64 extends UInt.with(64) {
        __UIntType = 'u64';
    }

    class u128 extends UInt.with(128) {
        __UIntType = 'u128';
    }

    class u256 extends UInt.with(256) {
        __UIntType = 'u256';
    }

    class usize extends u32 {
        constructor(registry, value) {
            super(registry, value);
            throw new Error('The `usize` type should not be used. Since it is platform-specific, it creates incompatibilities between native (generally u64) and WASM (always u32) code. Use one of the `u32` or `u64` types explicitly.');
        }
    }

    function typeSplit(type) {
        const result = [];
        let c = 0;
        let f = 0;
        let s = 0;
        let t = 0;
        let start = 0;
        for (let i = 0, count = type.length; i < count; i++) {
            switch (type[i]) {
                case ',': {
                    if (!(c || f || s || t)) {
                        result.push(type.substring(start, i).trim());
                        start = i + 1;
                    }
                    break;
                }
                case '<':
                    c++;
                    break;
                case '>':
                    c--;
                    break;
                case '[':
                    f++;
                    break;
                case ']':
                    f--;
                    break;
                case '{':
                    s++;
                    break;
                case '}':
                    s--;
                    break;
                case '(':
                    t++;
                    break;
                case ')':
                    t--;
                    break;
            }
        }
        if (c || f || s || t) {
            throw new Error(`Invalid definition (missing terminators) found in ${type}`);
        }
        result.push(type.substring(start, type.length).trim());
        return result;
    }

    const KNOWN_INTERNALS = ['_alias', '_fallback'];
    function getTypeString(typeOrObj) {
        return util.isString(typeOrObj)
            ? typeOrObj.toString()
            : util.stringify(typeOrObj);
    }
    function isRustEnum(details) {
        const values = Object.values(details);
        if (values.some((v) => util.isNumber(v))) {
            if (!values.every((v) => util.isNumber(v) && v >= 0 && v <= 255)) {
                throw new Error('Invalid number-indexed enum definition');
            }
            return false;
        }
        return true;
    }
    function _decodeEnum(value, details, count, fallbackType) {
        value.info = exports.TypeDefInfo.Enum;
        value.fallbackType = fallbackType;
        if (Array.isArray(details)) {
            value.sub = details.map((name, index) => ({
                index,
                info: exports.TypeDefInfo.Plain,
                name,
                type: 'Null'
            }));
        }
        else if (isRustEnum(details)) {
            value.sub = Object.entries(details).map(([name, typeOrObj], index) => util.objectSpread({}, getTypeDef(getTypeString(typeOrObj || 'Null'), { name }, count), { index }));
        }
        else {
            value.sub = Object.entries(details).map(([name, index]) => ({
                index,
                info: exports.TypeDefInfo.Plain,
                name,
                type: 'Null'
            }));
        }
        return value;
    }
    function _decodeSet(value, details, fallbackType) {
        value.info = exports.TypeDefInfo.Set;
        value.fallbackType = fallbackType;
        value.length = details._bitLength;
        value.sub = Object
            .entries(details)
            .filter(([name]) => !name.startsWith('_'))
            .map(([name, index]) => ({
            index,
            info: exports.TypeDefInfo.Plain,
            name,
            type: 'Null'
        }));
        return value;
    }
    function _decodeStruct(value, type, _, count) {
        const parsed = JSON.parse(type);
        const keys = Object.keys(parsed);
        if (parsed._enum) {
            return _decodeEnum(value, parsed._enum, count, parsed._fallback);
        }
        else if (parsed._set) {
            return _decodeSet(value, parsed._set, parsed._fallback);
        }
        value.alias = parsed._alias
            ? new Map(Object.entries(parsed._alias))
            : undefined;
        value.fallbackType = parsed._fallback;
        value.sub = keys
            .filter((name) => !KNOWN_INTERNALS.includes(name))
            .map((name) => getTypeDef(getTypeString(parsed[name]), { name }, count));
        return value;
    }
    function _decodeFixedVec(value, type, _, count) {
        const max = type.length - 1;
        let index = -1;
        let inner = 0;
        for (let i = 1; (i < max) && (index === -1); i++) {
            switch (type[i]) {
                case ';': {
                    if (inner === 0) {
                        index = i;
                    }
                    break;
                }
                case '[':
                case '(':
                case '<':
                    inner++;
                    break;
                case ']':
                case ')':
                case '>':
                    inner--;
                    break;
            }
        }
        if (index === -1) {
            throw new Error(`${type}: Unable to extract location of ';'`);
        }
        const vecType = type.substring(1, index);
        const [strLength, displayName] = type.substring(index + 1, max).split(';');
        const length = parseInt(strLength.trim(), 10);
        if (length > 2048) {
            throw new Error(`${type}: Only support for [Type; <length>], where length <= 2048`);
        }
        value.displayName = displayName;
        value.length = length;
        value.sub = getTypeDef(vecType, {}, count);
        return value;
    }
    function _decodeTuple(value, _, subType, count) {
        value.sub = subType.length === 0
            ? []
            : typeSplit(subType).map((inner) => getTypeDef(inner, {}, count));
        return value;
    }
    function _decodeAnyInt(value, type, _, clazz) {
        const [strLength, displayName] = type.substring(clazz.length + 1, type.length - 1).split(',');
        const length = parseInt(strLength.trim(), 10);
        if ((length > 8192) || (length % 8)) {
            throw new Error(`${type}: Only support for ${clazz}<bitLength>, where length <= 8192 and a power of 8, found ${length}`);
        }
        value.displayName = displayName;
        value.length = length;
        return value;
    }
    function _decodeInt(value, type, subType) {
        return _decodeAnyInt(value, type, subType, 'Int');
    }
    function _decodeUInt(value, type, subType) {
        return _decodeAnyInt(value, type, subType, 'UInt');
    }
    function _decodeDoNotConstruct(value, type, _) {
        const NAME_LENGTH = 'DoNotConstruct'.length;
        value.displayName = type.substring(NAME_LENGTH + 1, type.length - 1);
        return value;
    }
    function hasWrapper(type, [start, end]) {
        return (type.startsWith(start)) && (type.slice(-1 * end.length) === end);
    }
    const nestedExtraction = [
        ['[', ']', exports.TypeDefInfo.VecFixed, _decodeFixedVec],
        ['{', '}', exports.TypeDefInfo.Struct, _decodeStruct],
        ['(', ')', exports.TypeDefInfo.Tuple, _decodeTuple],
        ['BTreeMap<', '>', exports.TypeDefInfo.BTreeMap, _decodeTuple],
        ['HashMap<', '>', exports.TypeDefInfo.HashMap, _decodeTuple],
        ['Int<', '>', exports.TypeDefInfo.Int, _decodeInt],
        ['Result<', '>', exports.TypeDefInfo.Result, _decodeTuple],
        ['UInt<', '>', exports.TypeDefInfo.UInt, _decodeUInt],
        ['DoNotConstruct<', '>', exports.TypeDefInfo.DoNotConstruct, _decodeDoNotConstruct]
    ];
    const wrappedExtraction = [
        ['BTreeSet<', '>', exports.TypeDefInfo.BTreeSet],
        ['Compact<', '>', exports.TypeDefInfo.Compact],
        ['Linkage<', '>', exports.TypeDefInfo.Linkage],
        ['Opaque<', '>', exports.TypeDefInfo.WrapperOpaque],
        ['Option<', '>', exports.TypeDefInfo.Option],
        ['Range<', '>', exports.TypeDefInfo.Range],
        ['RangeInclusive<', '>', exports.TypeDefInfo.RangeInclusive],
        ['Vec<', '>', exports.TypeDefInfo.Vec],
        ['WrapperKeepOpaque<', '>', exports.TypeDefInfo.WrapperKeepOpaque],
        ['WrapperOpaque<', '>', exports.TypeDefInfo.WrapperOpaque]
    ];
    function extractSubType(type, [start, end]) {
        return type.substring(start.length, type.length - end.length);
    }
    function getTypeDef(_type, { displayName, name } = {}, count = 0) {
        const type = sanitize(_type);
        const value = { displayName, info: exports.TypeDefInfo.Plain, name, type };
        if (++count > 64) {
            throw new Error('getTypeDef: Maximum nested limit reached');
        }
        const nested = nestedExtraction.find((nested) => hasWrapper(type, nested));
        if (nested) {
            value.info = nested[2];
            return nested[3](value, type, extractSubType(type, nested), count);
        }
        const wrapped = wrappedExtraction.find((wrapped) => hasWrapper(type, wrapped));
        if (wrapped) {
            value.info = wrapped[2];
            value.sub = getTypeDef(extractSubType(type, wrapped), {}, count);
        }
        return value;
    }

    function getTypeDefType({ lookupName, type }) {
        return lookupName || type;
    }
    function getSubDefArray(value) {
        if (!Array.isArray(value.sub)) {
            throw new Error(`Expected subtype as TypeDef[] in ${util.stringify(value)}`);
        }
        return value.sub;
    }
    function getSubDef(value) {
        if (!value.sub || Array.isArray(value.sub)) {
            throw new Error(`Expected subtype as TypeDef in ${util.stringify(value)}`);
        }
        return value.sub;
    }
    function getSubType(value) {
        return getTypeDefType(getSubDef(value));
    }
    function getTypeClassMap(value) {
        const subs = getSubDefArray(value);
        const map = {};
        for (let i = 0, count = subs.length; i < count; i++) {
            const sub = subs[i];
            if (!sub.name) {
                throw new Error(`No name found in definition ${util.stringify(sub)}`);
            }
            map[sub.name] = getTypeDefType(sub);
        }
        return map;
    }
    function getTypeClassArray(value) {
        return getSubDefArray(value).map(getTypeDefType);
    }
    function createInt(Clazz, { displayName, length }) {
        if (!util.isNumber(length)) {
            throw new Error(`Expected bitLength information for ${displayName || Clazz.constructor.name}<bitLength>`);
        }
        return Clazz.with(length, displayName);
    }
    function createHashMap(Clazz, value) {
        const [keyType, valueType] = getTypeClassArray(value);
        return Clazz.with(keyType, valueType);
    }
    function createWithSub(Clazz, value) {
        return Clazz.with(getSubType(value));
    }
    const infoMapping = {
        [exports.TypeDefInfo.BTreeMap]: (_registry, value) => createHashMap(BTreeMap, value),
        [exports.TypeDefInfo.BTreeSet]: (_registry, value) => createWithSub(BTreeSet, value),
        [exports.TypeDefInfo.Compact]: (_registry, value) => createWithSub(Compact, value),
        [exports.TypeDefInfo.DoNotConstruct]: (_registry, value) => DoNotConstruct.with(value.displayName || value.type),
        [exports.TypeDefInfo.Enum]: (_registry, value) => {
            const subs = getSubDefArray(value);
            return Enum.with(subs.every(({ type }) => type === 'Null')
                ? subs.reduce((out, { index, name }, count) => {
                    if (!name) {
                        throw new Error('No name found in sub definition');
                    }
                    out[name] = index || count;
                    return out;
                }, {})
                : getTypeClassMap(value));
        },
        [exports.TypeDefInfo.HashMap]: (_registry, value) => createHashMap(HashMap, value),
        [exports.TypeDefInfo.Int]: (_registry, value) => createInt(Int, value),
        [exports.TypeDefInfo.Linkage]: (_registry, value) => {
            const type = `Option<${getSubType(value)}>`;
            const Clazz = Struct.with({ previous: type, next: type });
            Clazz.prototype.toRawType = function () {
                return `Linkage<${this.next.toRawType(true)}>`;
            };
            return Clazz;
        },
        [exports.TypeDefInfo.Null]: (_registry, _value) => Null,
        [exports.TypeDefInfo.Option]: (_registry, value) => {
            if (!value.sub || Array.isArray(value.sub)) {
                throw new Error('Expected type information for Option');
            }
            return createWithSub(Option, value);
        },
        [exports.TypeDefInfo.Plain]: (registry, value) => registry.getOrUnknown(value.type),
        [exports.TypeDefInfo.Range]: (_registry, value) => createWithSub(Range, value),
        [exports.TypeDefInfo.RangeInclusive]: (_registry, value) => createWithSub(RangeInclusive, value),
        [exports.TypeDefInfo.Result]: (_registry, value) => {
            const [Ok, Err] = getTypeClassArray(value);
            return Result.with({ Err, Ok });
        },
        [exports.TypeDefInfo.Set]: (_registry, value) => CodecSet.with(getSubDefArray(value).reduce((result, { index, name }) => {
            if (!name || !util.isNumber(index)) {
                throw new Error('No name found in sub definition');
            }
            result[name] = index;
            return result;
        }, {}), value.length),
        [exports.TypeDefInfo.Si]: (registry, value) => getTypeClass(registry, registry.lookup.getTypeDef(value.type)),
        [exports.TypeDefInfo.Struct]: (_registry, value) => Struct.with(getTypeClassMap(value), value.alias),
        [exports.TypeDefInfo.Tuple]: (_registry, value) => Tuple.with(getTypeClassArray(value)),
        [exports.TypeDefInfo.UInt]: (_registry, value) => createInt(UInt, value),
        [exports.TypeDefInfo.Vec]: (_registry, { sub }) => {
            if (!sub || Array.isArray(sub)) {
                throw new Error('Expected type information for vector');
            }
            return (sub.type === 'u8'
                ? Bytes
                : Vec.with(getTypeDefType(sub)));
        },
        [exports.TypeDefInfo.VecFixed]: (_registry, { displayName, length, sub }) => {
            if (!util.isNumber(length) || !sub || Array.isArray(sub)) {
                throw new Error('Expected length & type information for fixed vector');
            }
            return (sub.type === 'u8'
                ? U8aFixed.with((length * 8), displayName)
                : VecFixed.with(getTypeDefType(sub), length));
        },
        [exports.TypeDefInfo.WrapperKeepOpaque]: (_registry, value) => createWithSub(WrapperKeepOpaque, value),
        [exports.TypeDefInfo.WrapperOpaque]: (_registry, value) => createWithSub(WrapperOpaque, value)
    };
    function constructTypeClass(registry, typeDef) {
        try {
            const Type = infoMapping[typeDef.info](registry, typeDef);
            if (!Type) {
                throw new Error('No class created');
            }
            if (!Type.__fallbackType && typeDef.fallbackType) {
                Type.__fallbackType = typeDef.fallbackType;
            }
            return Type;
        }
        catch (error) {
            throw new Error(`Unable to construct class from ${util.stringify(typeDef)}: ${error.message}`);
        }
    }
    function getTypeClass(registry, typeDef) {
        return registry.getUnsafe(typeDef.type, false, typeDef);
    }
    function createClassUnsafe(registry, type) {
        return (
        registry.getUnsafe(type) ||
            getTypeClass(registry, registry.isLookupType(type)
                ? registry.lookup.getTypeDef(type)
                : getTypeDef(type)));
    }

    function checkInstance(created, matcher) {
        const u8a = created.toU8a();
        const rawType = created.toRawType();
        const isOk = (
        util.u8aEq(u8a, matcher) ||
            (
            ['Bytes', 'Text', 'Type'].includes(rawType) &&
                matcher.length === created.length) ||
            (
            created.isEmpty &&
                matcher.every((v) => !v)));
        if (!isOk) {
            throw new Error(`${rawType}:: Decoded input doesn't match input, received ${util.u8aToHex(matcher, 512)} (${matcher.length} bytes), created ${util.u8aToHex(u8a, 512)} (${u8a.length} bytes)`);
        }
    }
    function checkPedantic(created, [value]) {
        if (util.isU8a(value)) {
            checkInstance(created, value);
        }
        else if (util.isHex(value)) {
            checkInstance(created, util.u8aToU8a(value));
        }
    }
    function initType(registry, Type, params = [], { blockHash, isFallback, isOptional, isPedantic } = {}) {
        const created = new (isOptional
            ? Option.with(Type)
            : Type)(registry, ...params);
        isPedantic && checkPedantic(created, params);
        if (blockHash) {
            created.createdAtHash = createTypeUnsafe(registry, 'BlockHash', [blockHash]);
        }
        if (isFallback) {
            created.isStorageFallback = true;
        }
        return created;
    }
    function createTypeUnsafe(registry, type, params = [], options = {}) {
        let Clazz = null;
        let firstError = null;
        try {
            Clazz = createClassUnsafe(registry, type);
            return initType(registry, Clazz, params, options);
        }
        catch (error) {
            firstError = new Error(`createType(${type}):: ${error.message}`);
        }
        if (Clazz?.__fallbackType) {
            try {
                Clazz = createClassUnsafe(registry, Clazz.__fallbackType);
                return initType(registry, Clazz, params, options);
            }
            catch {
            }
        }
        throw firstError;
    }

    const stringIdentity = (value) => value.toString();
    const INFO_WRAP = ['BTreeMap', 'BTreeSet', 'Compact', 'HashMap', 'Option', 'Result', 'Vec'];
    function paramsNotation(outer, inner, transform = stringIdentity) {
        return `${outer}${inner
        ? `<${(Array.isArray(inner) ? inner : [inner]).map(transform).join(', ')}>`
        : ''}`;
    }
    function encodeWithParams(registry, typeDef, outer) {
        const { info, sub } = typeDef;
        switch (info) {
            case exports.TypeDefInfo.BTreeMap:
            case exports.TypeDefInfo.BTreeSet:
            case exports.TypeDefInfo.Compact:
            case exports.TypeDefInfo.HashMap:
            case exports.TypeDefInfo.Linkage:
            case exports.TypeDefInfo.Option:
            case exports.TypeDefInfo.Range:
            case exports.TypeDefInfo.RangeInclusive:
            case exports.TypeDefInfo.Result:
            case exports.TypeDefInfo.Vec:
            case exports.TypeDefInfo.WrapperKeepOpaque:
            case exports.TypeDefInfo.WrapperOpaque:
                return paramsNotation(outer, sub, (p) => encodeTypeDef(registry, p));
        }
        throw new Error(`Unable to encode ${util.stringify(typeDef)} with params`);
    }
    function encodeSubTypes(registry, sub, asEnum, extra) {
        const names = sub.map(({ name }) => name);
        if (!names.every((n) => !!n)) {
            throw new Error(`Subtypes does not have consistent names, ${names.join(', ')}`);
        }
        const inner = util.objectSpread({}, extra);
        for (let i = 0, count = sub.length; i < count; i++) {
            const def = sub[i];
            if (!def.name) {
                throw new Error(`No name found in ${util.stringify(def)}`);
            }
            inner[def.name] = encodeTypeDef(registry, def);
        }
        return util.stringify(asEnum
            ? { _enum: inner }
            : inner);
    }
    const encoders = {
        [exports.TypeDefInfo.BTreeMap]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'BTreeMap'),
        [exports.TypeDefInfo.BTreeSet]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'BTreeSet'),
        [exports.TypeDefInfo.Compact]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Compact'),
        [exports.TypeDefInfo.DoNotConstruct]: (registry, { displayName, lookupIndex, lookupName }) => `DoNotConstruct<${lookupName || displayName || (util.isUndefined(lookupIndex) ? 'Unknown' : registry.createLookupType(lookupIndex))}>`,
        [exports.TypeDefInfo.Enum]: (registry, { sub }) => {
            if (!Array.isArray(sub)) {
                throw new Error('Unable to encode Enum type');
            }
            return sub.every(({ type }) => type === 'Null')
                ? util.stringify({ _enum: sub.map(({ name }, index) => `${name || `Empty${index}`}`) })
                : encodeSubTypes(registry, sub, true);
        },
        [exports.TypeDefInfo.HashMap]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'HashMap'),
        [exports.TypeDefInfo.Int]: (_registry, { length = 32 }) => `Int<${length}>`,
        [exports.TypeDefInfo.Linkage]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Linkage'),
        [exports.TypeDefInfo.Null]: (_registry, _typeDef) => 'Null',
        [exports.TypeDefInfo.Option]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Option'),
        [exports.TypeDefInfo.Plain]: (_registry, { displayName, type }) => displayName || type,
        [exports.TypeDefInfo.Range]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Range'),
        [exports.TypeDefInfo.RangeInclusive]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'RangeInclusive'),
        [exports.TypeDefInfo.Result]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Result'),
        [exports.TypeDefInfo.Set]: (_registry, { length = 8, sub }) => {
            if (!Array.isArray(sub)) {
                throw new Error('Unable to encode Set type');
            }
            return util.stringify({
                _set: sub.reduce((all, { index, name }, count) => util.objectSpread(all, { [`${name || `Unknown${index || count}`}`]: index || count }), { _bitLength: length || 8 })
            });
        },
        [exports.TypeDefInfo.Si]: (_registry, { lookupName, type }) => lookupName || type,
        [exports.TypeDefInfo.Struct]: (registry, { alias, sub }) => {
            if (!Array.isArray(sub)) {
                throw new Error('Unable to encode Struct type');
            }
            return encodeSubTypes(registry, sub, false, alias
                ? {
                    _alias: [...alias.entries()].reduce((all, [k, v]) => util.objectSpread(all, { [k]: v }), {})
                }
                : {});
        },
        [exports.TypeDefInfo.Tuple]: (registry, { sub }) => {
            if (!Array.isArray(sub)) {
                throw new Error('Unable to encode Tuple type');
            }
            return `(${sub.map((type) => encodeTypeDef(registry, type)).join(',')})`;
        },
        [exports.TypeDefInfo.UInt]: (_registry, { length = 32 }) => `UInt<${length}>`,
        [exports.TypeDefInfo.Vec]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Vec'),
        [exports.TypeDefInfo.VecFixed]: (_registry, { length, sub }) => {
            if (!util.isNumber(length) || !sub || Array.isArray(sub)) {
                throw new Error('Unable to encode VecFixed type');
            }
            return `[${sub.type};${length}]`;
        },
        [exports.TypeDefInfo.WrapperKeepOpaque]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'WrapperKeepOpaque'),
        [exports.TypeDefInfo.WrapperOpaque]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'WrapperOpaque')
    };
    function encodeType(registry, typeDef, withLookup = true) {
        return withLookup && typeDef.lookupName
            ? typeDef.lookupName
            : encoders[typeDef.info](registry, typeDef);
    }
    function encodeTypeDef(registry, typeDef) {
        return (typeDef.displayName && !INFO_WRAP.some((i) => typeDef.displayName === i))
            ? typeDef.displayName
            : encodeType(registry, typeDef);
    }
    function withTypeString(registry, typeDef) {
        return util.objectSpread({}, typeDef, {
            type: encodeType(registry, typeDef, false)
        });
    }

    const XCM_MAPPINGS = ['AssetInstance', 'Fungibility', 'Junction', 'Junctions', 'MultiAsset', 'MultiAssetFilter', 'MultiLocation', 'Response', 'WildFungibility', 'WildMultiAsset', 'Xcm', 'XcmError', 'XcmOrder'];
    function mapXcmTypes(version) {
        return XCM_MAPPINGS.reduce((all, key) => util.objectSpread(all, { [key]: `${key}${version}` }), {});
    }

    const v0 = {
        FungibilityV0: 'FungibilityV1',
        WildFungibilityV0: 'WildFungibilityV1',
        AssetInstanceV0: {
            _enum: {
                Undefined: 'Null',
                Index8: 'u8',
                Index16: 'Compact<u16>',
                Index32: 'Compact<u32>',
                Index64: 'Compact<u64>',
                Index128: 'Compact<u128>',
                Array4: '[u8; 4]',
                Array8: '[u8; 8]',
                Array16: '[u8; 16]',
                Array32: '[u8; 32]',
                Blob: 'Vec<u8>'
            }
        },
        JunctionV0: {
            _enum: {
                Parent: 'Null',
                Parachain: 'Compact<u32>',
                AccountId32: {
                    network: 'NetworkId',
                    id: 'AccountId'
                },
                AccountIndex64: {
                    network: 'NetworkId',
                    index: 'Compact<u64>'
                },
                AccountKey20: {
                    network: 'NetworkId',
                    key: '[u8; 20]'
                },
                PalletInstance: 'u8',
                GeneralIndex: 'Compact<u128>',
                GeneralKey: 'Vec<u8>',
                OnlyChild: 'Null',
                Plurality: {
                    id: 'BodyId',
                    part: 'BodyPart'
                }
            }
        },
        MultiAssetV0: {
            _enum: {
                None: 'Null',
                All: 'Null',
                AllFungible: 'Null',
                AllNonFungible: 'Null',
                AllAbstractFungible: 'Vec<u8>',
                AllAbstractNonFungible: 'Vec<u8>',
                AllConcreteFungible: 'MultiLocationV0',
                AllConcreteNonFungible: 'MultiLocationV0',
                AbstractFungible: {
                    id: 'Vec<u8>',
                    instance: 'Compact<u128>'
                },
                AbstractNonFungible: {
                    class: 'Vec<u8>',
                    instance: 'AssetInstanceV0'
                },
                ConcreteFungible: {
                    id: 'MultiLocationV0',
                    amount: 'Compact<u128>'
                },
                ConcreteNonFungible: {
                    class: 'MultiLocationV0',
                    instance: 'AssetInstanceV0'
                }
            }
        },
        MultiLocationV0: {
            _enum: {
                Here: 'Null',
                X1: 'JunctionV0',
                X2: '(JunctionV0, JunctionV0)',
                X3: '(JunctionV0, JunctionV0, JunctionV0)',
                X4: '(JunctionV0, JunctionV0, JunctionV0, JunctionV0)',
                X5: '(JunctionV0, JunctionV0, JunctionV0, JunctionV0, JunctionV0)',
                X6: '(JunctionV0, JunctionV0, JunctionV0, JunctionV0, JunctionV0, JunctionV0)',
                X7: '(JunctionV0, JunctionV0, JunctionV0, JunctionV0, JunctionV0, JunctionV0, JunctionV0)',
                X8: '(JunctionV0, JunctionV0, JunctionV0, JunctionV0, JunctionV0, JunctionV0, JunctionV0, JunctionV0)'
            }
        },
        OriginKindV0: {
            _enum: ['Native', 'SovereignAccount', 'Superuser', 'Xcm']
        },
        ResponseV0: {
            _enum: {
                Assets: 'Vec<MultiAssetV0>'
            }
        },
        XcmV0: {
            _enum: {
                WithdrawAsset: {
                    assets: 'Vec<MultiAssetV0>',
                    effects: 'Vec<XcmOrderV0>'
                },
                ReserveAssetDeposit: {
                    assets: 'Vec<MultiAssetV0>',
                    effects: 'Vec<XcmOrderV0>'
                },
                ReceiveTeleportedAsset: {
                    assets: 'Vec<MultiAssetV0>',
                    effects: 'Vec<XcmOrderV0>'
                },
                QueryResponse: {
                    queryId: 'Compact<u64>',
                    response: 'ResponseV0'
                },
                TransferAsset: {
                    assets: 'Vec<MultiAssetV0>',
                    dest: 'MultiLocationV0'
                },
                TransferReserveAsset: {
                    assets: 'Vec<MultiAssetV0>',
                    dest: 'MultiLocationV0',
                    effects: 'Vec<XcmOrderV0>'
                },
                Transact: {
                    originType: 'XcmOriginKind',
                    requireWeightAtMost: 'u64',
                    call: 'DoubleEncodedCall'
                },
                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: 'MultiLocationV0',
                    message: 'XcmV0'
                }
            }
        },
        XcmErrorV0: {
            _enum: {
                Undefined: 'Null',
                Overflow: 'Null',
                Unimplemented: 'Null',
                UnhandledXcmVersion: 'Null',
                UnhandledXcmMessage: 'Null',
                UnhandledEffect: 'Null',
                EscalationOfPrivilege: 'Null',
                UntrustedReserveLocation: 'Null',
                UntrustedTeleportLocation: 'Null',
                DestinationBufferOverflow: 'Null',
                SendFailed: 'Null',
                CannotReachDestination: '(MultiLocation, Xcm)',
                MultiLocationFull: 'Null',
                FailedToDecode: 'Null',
                BadOrigin: 'Null',
                ExceedsMaxMessageSize: 'Null',
                FailedToTransactAsset: 'Null',
                WeightLimitReached: 'Weight',
                Wildcard: 'Null',
                TooMuchWeightRequired: 'Null',
                NotHoldingFees: 'Null',
                WeightNotComputable: 'Null',
                Barrier: 'Null',
                NotWithdrawable: 'Null',
                LocationCannotHold: 'Null',
                TooExpensive: 'Null',
                AssetNotFound: 'Null',
                RecursionLimitReached: 'Null'
            }
        },
        XcmOrderV0: {
            _enum: {
                Null: 'Null',
                DepositAsset: {
                    assets: 'Vec<MultiAssetV0>',
                    dest: 'MultiLocationV0'
                },
                DepositReserveAsset: {
                    assets: 'Vec<MultiAssetV0>',
                    dest: 'MultiLocationV0',
                    effects: 'Vec<XcmOrderV0>'
                },
                ExchangeAsset: {
                    give: 'Vec<MultiAssetV0>',
                    receive: 'Vec<MultiAssetV0>'
                },
                InitiateReserveWithdraw: {
                    assets: 'Vec<MultiAssetV0>',
                    reserve: 'MultiLocationV0',
                    effects: 'Vec<XcmOrderV0>'
                },
                InitiateTeleport: {
                    assets: 'Vec<MultiAssetV0>',
                    dest: 'MultiLocationV0',
                    effects: 'Vec<XcmOrderV0>'
                },
                QueryHolding: {
                    queryId: 'Compact<u64>',
                    dest: 'MultiLocationV0',
                    assets: 'Vec<MultiAssetV0>'
                },
                BuyExecution: {
                    fees: 'MultiAssetV0',
                    weight: 'u64',
                    debt: 'u64',
                    haltOnError: 'bool',
                    xcm: 'Vec<XcmV0>'
                }
            }
        }
    };

    const v1 = {
        AssetInstanceV1: {
            _enum: {
                Undefined: 'Null',
                Index: 'Compact<u128>',
                Array4: '[u8; 4]',
                Array8: '[u8; 8]',
                Array16: '[u8; 16]',
                Array32: '[u8; 32]',
                Blob: 'Bytes'
            }
        },
        FungibilityV1: {
            _enum: {
                Fungible: 'Compact<u128>',
                NonFungible: 'AssetInstanceV1'
            }
        },
        JunctionV1: {
            _enum: {
                Parachain: 'Compact<u32>',
                AccountId32: {
                    network: 'NetworkId',
                    id: 'AccountId'
                },
                AccountIndex64: {
                    network: 'NetworkId',
                    index: 'Compact<u64>'
                },
                AccountKey20: {
                    network: 'NetworkId',
                    key: '[u8; 20]'
                },
                PalletInstance: 'u8',
                GeneralIndex: 'Compact<u128>',
                GeneralKey: 'Vec<u8>',
                OnlyChild: 'Null',
                Plurality: {
                    id: 'BodyId',
                    part: 'BodyPart'
                }
            }
        },
        JunctionsV1: {
            _enum: {
                Here: 'Null',
                X1: 'JunctionV1',
                X2: '(JunctionV1, JunctionV1)',
                X3: '(JunctionV1, JunctionV1, JunctionV1)',
                X4: '(JunctionV1, JunctionV1, JunctionV1, JunctionV1)',
                X5: '(JunctionV1, JunctionV1, JunctionV1, JunctionV1, JunctionV1)',
                X6: '(JunctionV1, JunctionV1, JunctionV1, JunctionV1, JunctionV1, JunctionV1)',
                X7: '(JunctionV1, JunctionV1, JunctionV1, JunctionV1, JunctionV1, JunctionV1, JunctionV1)',
                X8: '(JunctionV1, JunctionV1, JunctionV1, JunctionV1, JunctionV1, JunctionV1, JunctionV1, JunctionV1)'
            }
        },
        MultiAssetsV1: 'Vec<MultiAssetV1>',
        MultiAssetV1: {
            id: 'XcmAssetId',
            fungibility: 'FungibilityV1'
        },
        MultiAssetFilterV1: {
            _enum: {
                Definite: 'MultiAssetsV1',
                Wild: 'WildMultiAssetV1'
            }
        },
        MultiLocationV1: {
            parents: 'u8',
            interior: 'JunctionsV1'
        },
        OriginKindV1: 'OriginKindV0',
        ResponseV1: {
            _enum: {
                Assets: 'MultiAssetsV1'
            }
        },
        WildFungibilityV1: {
            _enum: ['Fungible', 'NonFungible']
        },
        WildMultiAssetV1: {
            _enum: {
                All: 'Null',
                AllOf: {
                    id: 'XcmAssetId',
                    fungibility: 'WildFungibilityV1'
                }
            }
        },
        XcmV1: {
            _enum: {
                WithdrawAsset: {
                    assets: 'MultiAssetsV1',
                    effects: 'Vec<XcmOrderV1>'
                },
                ReserveAssetDeposit: {
                    assets: 'MultiAssetsV1',
                    effects: 'Vec<XcmOrderV1>'
                },
                ReceiveTeleportedAsset: {
                    assets: 'MultiAssetsV1',
                    effects: 'Vec<XcmOrderV1>'
                },
                QueryResponse: {
                    queryId: 'Compact<u64>',
                    response: 'ResponseV1'
                },
                TransferAsset: {
                    assets: 'MultiAssetsV1',
                    dest: 'MultiLocationV1'
                },
                TransferReserveAsset: {
                    assets: 'MultiAssetsV1',
                    dest: 'MultiLocationV1',
                    effects: 'Vec<XcmOrderV1>'
                },
                Transact: {
                    originType: 'XcmOriginKind',
                    requireWeightAtMost: 'u64',
                    call: 'DoubleEncodedCall'
                },
                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: 'MultiLocationV1',
                    message: 'XcmV1'
                }
            }
        },
        XcmErrorV1: {
            _enum: {
                Undefined: 'Null',
                Overflow: 'Null',
                Unimplemented: 'Null',
                UnhandledXcmVersion: 'Null',
                UnhandledXcmMessage: 'Null',
                UnhandledEffect: 'Null',
                EscalationOfPrivilege: 'Null',
                UntrustedReserveLocation: 'Null',
                UntrustedTeleportLocation: 'Null',
                DestinationBufferOverflow: 'Null',
                SendFailed: 'Null',
                CannotReachDestination: '(MultiLocationV1, XcmV1)',
                MultiLocationFull: 'Null',
                FailedToDecode: 'Null',
                BadOrigin: 'Null',
                ExceedsMaxMessageSize: 'Null',
                FailedToTransactAsset: 'Null',
                WeightLimitReached: 'Weight',
                Wildcard: 'Null',
                TooMuchWeightRequired: 'Null',
                NotHoldingFees: 'Null',
                WeightNotComputable: 'Null',
                Barrier: 'Null',
                NotWithdrawable: 'Null',
                LocationCannotHold: 'Null',
                TooExpensive: 'Null',
                AssetNotFound: 'Null',
                DestinationUnsupported: 'Null',
                RecursionLimitReached: 'Null'
            }
        },
        XcmOrderV1: {
            _enum: {
                Noop: 'Null',
                DepositAsset: {
                    assets: 'MultiAssetFilterV1',
                    maxAssets: 'u32',
                    beneficiary: 'MultiLocationV1'
                },
                DepositReserveAsset: {
                    assets: 'MultiAssetFilterV1',
                    maxAssets: 'u32',
                    dest: 'MultiLocationV1',
                    effects: 'Vec<XcmOrderV1>'
                },
                ExchangeAsset: {
                    give: 'MultiAssetFilterV1',
                    receive: 'MultiAssetsV1'
                },
                InitiateReserveWithdraw: {
                    assets: 'MultiAssetFilterV1',
                    reserve: 'MultiLocationV1',
                    effects: 'Vec<XcmOrderV1>'
                },
                InitiateTeleport: {
                    assets: 'MultiAssetFilterV1',
                    dest: 'MultiLocationV1',
                    effects: 'Vec<XcmOrderV1>'
                },
                QueryHolding: {
                    queryId: 'Compact<u64>',
                    dest: 'MultiLocationV1',
                    assets: 'MultiAssetFilterV1'
                },
                BuyExecution: {
                    fees: 'MultiAssetV1',
                    weight: 'u64',
                    debt: 'u64',
                    haltOnError: 'bool',
                    instructions: 'Vec<XcmV1>'
                }
            }
        }
    };

    const v2 = {
        AssetInstanceV2: 'AssetInstanceV1',
        FungibilityV2: 'FungibilityV1',
        JunctionV2: 'JunctionV1',
        JunctionsV2: 'JunctionsV1',
        MultiAssetsV2: 'MultiAssetsV1',
        MultiAssetV2: 'MultiAssetV1',
        MultiAssetFilterV2: 'MultiAssetFilterV1',
        MultiLocationV2: 'MultiLocationV1',
        OriginKindV2: 'OriginKindV1',
        WildFungibilityV2: 'WildFungibilityV1',
        ResponseV2: {
            _enum: {
                Null: 'Null',
                Assets: 'MultiAssetsV2',
                ExecutionResult: 'ResponseV2Result'
            }
        },
        ResponseV2Error: '(u32, XcmErrorV2)',
        ResponseV2Result: 'Result<Null, ResponseV2Error>',
        WeightLimitV2: {
            _enum: {
                Unlimited: 'Null',
                Limited: 'Compact<u64>'
            }
        },
        InstructionV2: {
            _enum: {
                WithdrawAsset: 'MultiAssetsV2',
                ReserveAssetDeposited: 'MultiAssetsV2',
                ReceiveTeleportedAsset: 'MultiAssetsV2',
                QueryResponse: {
                    queryId: 'Compact<u64>',
                    response: 'ResponseV2',
                    maxWeight: 'Compact<u64>'
                },
                TransferAsset: {
                    assets: 'MultiAssetsV2',
                    beneficiary: 'MultiLocationV2'
                },
                TransferReserveAsset: {
                    assets: 'MultiAssetsV2',
                    dest: 'MultiLocationV2',
                    xcm: 'XcmV2'
                },
                Transact: {
                    originType: 'OriginKindV2',
                    requireWeightAtMost: 'u64',
                    call: 'DoubleEncodedCall'
                },
                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: 'InteriorMultiLocation',
                ReportError: {
                    queryId: 'Compact<u64>',
                    dest: 'MultiLocationV2',
                    maxResponseWeight: 'Compact<u64>'
                },
                DepositAsset: {
                    assets: 'MultiAssetFilterV2',
                    maxAssets: 'u32',
                    beneficiary: 'MultiLocationV2'
                },
                DepositReserveAsset: {
                    assets: 'MultiAssetFilterV2',
                    maxAssets: 'u32',
                    dest: 'MultiLocationV2',
                    xcm: 'XcmV2'
                },
                ExchangeAsset: {
                    give: 'MultiAssetFilterV2',
                    receive: 'MultiAssetsV2'
                },
                InitiateReserveWithdraw: {
                    assets: 'MultiAssetFilterV2',
                    reserve: 'MultiLocationV2',
                    xcm: 'XcmV2'
                },
                InitiateTeleport: {
                    assets: 'MultiAssetFilterV2',
                    dest: 'MultiLocationV2',
                    xcm: 'XcmV2'
                },
                QueryHolding: {
                    query_id: 'Compact<u64>',
                    dest: 'MultiLocationV2',
                    assets: 'MultiAssetFilterV2',
                    maxResponse_Weight: 'Compact<u64>'
                },
                BuyExecution: {
                    fees: 'MultiAssetV2',
                    weightLimit: 'WeightLimitV2'
                },
                RefundSurplus: 'Null',
                SetErrorHandler: 'XcmV2',
                SetAppendix: 'XcmV2',
                ClearError: 'Null',
                ClaimAsset: {
                    assets: 'MultiAssetsV2',
                    ticket: 'MultiLocationV2'
                },
                Trap: 'u64'
            }
        },
        WildMultiAssetV2: 'WildMultiAssetV1',
        XcmV2: 'Vec<InstructionV2>',
        XcmErrorV2: {
            _enum: {
                Undefined: 'Null',
                Overflow: 'Null',
                Unimplemented: 'Null',
                UnhandledXcmVersion: 'Null',
                UnhandledXcmMessage: 'Null',
                UnhandledEffect: 'Null',
                EscalationOfPrivilege: 'Null',
                UntrustedReserveLocation: 'Null',
                UntrustedTeleportLocation: 'Null',
                DestinationBufferOverflow: 'Null',
                MultiLocationFull: 'Null',
                MultiLocationNotInvertible: 'Null',
                FailedToDecode: 'Null',
                BadOrigin: 'Null',
                ExceedsMaxMessageSize: 'Null',
                FailedToTransactAsset: 'Null',
                WeightLimitReached: 'Weight',
                Wildcard: 'Null',
                TooMuchWeightRequired: 'Null',
                NotHoldingFees: 'Null',
                WeightNotComputable: 'Null',
                Barrier: 'Null',
                NotWithdrawable: 'Null',
                LocationCannotHold: 'Null',
                TooExpensive: 'Null',
                AssetNotFound: 'Null',
                DestinationUnsupported: 'Null',
                RecursionLimitReached: 'Null',
                Transport: 'Null',
                Unroutable: 'Null',
                UnknownWeightRequired: 'Null',
                Trap: 'u64',
                UnknownClaim: 'Null',
                InvalidLocation: 'Null'
            }
        },
        XcmOrderV2: 'XcmOrderV1'
    };

    const XCM_LATEST = 'V2';
    const xcm = {
        XcmOrigin: {
            _enum: {
                Xcm: 'MultiLocation'
            }
        },
        XcmpMessageFormat: {
            _enum: ['ConcatenatedVersionedXcm', 'ConcatenatedEncodedBlob', 'Signals']
        },
        XcmAssetId: {
            _enum: {
                Concrete: 'MultiLocation',
                Abstract: 'Bytes'
            }
        },
        InboundStatus: {
            _enum: ['Ok', 'Suspended']
        },
        OutboundStatus: {
            _enum: ['Ok', 'Suspended']
        },
        MultiAssets: 'Vec<MultiAsset>'
    };
    const location = {
        BodyId: {
            _enum: {
                Unit: 'Null',
                Named: 'Vec<u8>',
                Index: 'Compact<u32>',
                Executive: 'Null',
                Technical: 'Null',
                Legislative: 'Null',
                Judicial: 'Null'
            }
        },
        BodyPart: {
            _enum: {
                Voice: 'Null',
                Members: 'Compact<u32>',
                Fraction: {
                    nom: 'Compact<u32>',
                    denom: 'Compact<u32>'
                },
                AtLeastProportion: {
                    nom: 'Compact<u32>',
                    denom: 'Compact<u32>'
                },
                MoreThanProportion: {
                    nom: 'Compact<u32>',
                    denom: 'Compact<u32>'
                }
            }
        },
        InteriorMultiLocation: 'Junctions',
        NetworkId: {
            _enum: {
                Any: 'Null',
                Named: 'Vec<u8>',
                Polkadot: 'Null',
                Kusama: 'Null'
            }
        }
    };
    const definitions$d = {
        rpc: {},
        types: {
            ...location,
            ...xcm,
            ...v0,
            ...v1,
            ...v2,
            ...mapXcmTypes(XCM_LATEST),
            DoubleEncodedCall: {
                encoded: 'Vec<u8>'
            },
            XcmOriginKind: {
                _enum: ['Native', 'SovereignAccount', 'Superuser', 'Xcm']
            },
            Outcome: {
                _enum: {
                    Complete: 'Weight',
                    Incomplete: '(Weight, XcmErrorV0)',
                    Error: 'XcmErrorV0'
                }
            },
            QueryId: 'u64',
            QueryStatus: {
                _enum: {
                    Pending: {
                        responder: 'VersionedMultiLocation',
                        maybeNotify: 'Option<(u8, u8)>',
                        timeout: 'BlockNumber'
                    },
                    Ready: {
                        response: 'VersionedResponse',
                        at: 'BlockNumber'
                    }
                }
            },
            QueueConfigData: {
                suspendThreshold: 'u32',
                dropThreshold: 'u32',
                resumeThreshold: 'u32',
                thresholdWeight: 'Weight',
                weightRestrictDecay: 'Weight'
            },
            VersionMigrationStage: {
                _enum: {
                    MigrateSupportedVersion: 'Null',
                    MigrateVersionNotifiers: 'Null',
                    NotifyCurrentTargets: 'Option<Bytes>',
                    MigrateAndNotifyOldTargets: 'Null'
                }
            },
            VersionedMultiAsset: {
                _enum: {
                    V0: 'MultiAssetV0',
                    V1: 'MultiAssetV1',
                    V2: 'MultiAssetV2'
                }
            },
            VersionedMultiAssets: {
                _enum: {
                    V0: 'Vec<MultiAssetV0>',
                    V1: 'MultiAssetsV1',
                    V2: 'MultiAssetsV2'
                }
            },
            VersionedMultiLocation: {
                _enum: {
                    V0: 'MultiLocationV0',
                    V1: 'MultiLocationV1',
                    V2: 'MultiLocationV2'
                }
            },
            VersionedResponse: {
                V0: 'ResponseV0',
                V1: 'ResponseV1',
                V2: 'ResponseV2'
            },
            VersionedXcm: {
                _enum: {
                    V0: 'XcmV0',
                    V1: 'XcmV1',
                    V2: 'XcmV2'
                }
            },
            XcmVersion: 'u32'
        }
    };

    const layout = {
        ContractCryptoHasher: {
            _enum: ['Blake2x256', 'Sha2x256', 'Keccak256']
        },
        ContractDiscriminant: 'u32',
        ContractLayoutArray: {
            offset: 'ContractLayoutKey',
            len: 'u32',
            cellsPerElem: 'u64',
            layout: 'ContractStorageLayout'
        },
        ContractLayoutCell: {
            key: 'ContractLayoutKey',
            ty: 'SiLookupTypeId'
        },
        ContractLayoutEnum: {
            dispatchKey: 'ContractLayoutKey',
            variants: 'BTreeMap<ContractDiscriminant, ContractLayoutStruct>'
        },
        ContractLayoutHash: {
            offset: 'ContractLayoutKey',
            strategy: 'ContractLayoutHashingStrategy',
            layout: 'ContractStorageLayout'
        },
        ContractLayoutHashingStrategy: {
            hasher: 'ContractCryptoHasher',
            postfix: 'Vec<u8>',
            prefix: 'Vec<u8>'
        },
        ContractLayoutKey: '[u8; 32]',
        ContractLayoutStruct: {
            fields: 'Vec<ContractLayoutStructField>'
        },
        ContractLayoutStructField: {
            layout: 'ContractStorageLayout',
            name: 'Text'
        },
        ContractStorageLayout: {
            _enum: {
                Cell: 'ContractLayoutCell',
                Hash: 'ContractLayoutHash',
                Array: 'ContractLayoutArray',
                Struct: 'ContractLayoutStruct',
                Enum: 'ContractLayoutEnum'
            }
        }
    };
    const spec = {
        ContractConstructorSpecV0: {
            name: 'Text',
            selector: 'ContractSelector',
            args: 'Vec<ContractMessageParamSpecV0>',
            docs: 'Vec<Text>'
        },
        ContractConstructorSpecV1: {
            name: 'Vec<Text>',
            selector: 'ContractSelector',
            args: 'Vec<ContractMessageParamSpecV0>',
            docs: 'Vec<Text>'
        },
        ContractConstructorSpecV2: {
            label: 'Text',
            selector: 'ContractSelector',
            args: 'Vec<ContractMessageParamSpecV2>',
            docs: 'Vec<Text>'
        },
        ContractConstructorSpecV3: {
            label: 'Text',
            selector: 'ContractSelector',
            payable: 'bool',
            args: 'Vec<ContractMessageParamSpecV2>',
            docs: 'Vec<Text>'
        },
        ContractConstructorSpecV4: {
            label: 'Text',
            selector: 'ContractSelector',
            payable: 'bool',
            args: 'Vec<ContractMessageParamSpecV2>',
            docs: 'Vec<Text>',
            default: 'bool',
            returnType: 'Option<ContractTypeSpec>'
        },
        ContractContractSpecV0: {
            constructors: 'Vec<ContractConstructorSpecV0>',
            messages: 'Vec<ContractMessageSpecV0>',
            events: 'Vec<ContractEventSpecV0>',
            docs: 'Vec<Text>'
        },
        ContractContractSpecV1: {
            constructors: 'Vec<ContractConstructorSpecV1>',
            messages: 'Vec<ContractMessageSpecV1>',
            events: 'Vec<ContractEventSpecV1>',
            docs: 'Vec<Text>'
        },
        ContractContractSpecV2: {
            constructors: 'Vec<ContractConstructorSpecV2>',
            messages: 'Vec<ContractMessageSpecV2>',
            events: 'Vec<ContractEventSpecV2>',
            docs: 'Vec<Text>'
        },
        ContractContractSpecV3: {
            constructors: 'Vec<ContractConstructorSpecV3>',
            messages: 'Vec<ContractMessageSpecV2>',
            events: 'Vec<ContractEventSpecV2>',
            docs: 'Vec<Text>'
        },
        ContractContractSpecV4: {
            constructors: 'Vec<ContractConstructorSpecV4>',
            messages: 'Vec<ContractMessageSpecV3>',
            events: 'Vec<ContractEventSpecV2>',
            docs: 'Vec<Text>',
            environment: 'ContractEnvironmentV4'
        },
        ContractDisplayName: 'SiPath',
        ContractEventParamSpecV0: {
            name: 'Text',
            indexed: 'bool',
            type: 'ContractTypeSpec',
            docs: 'Vec<Text>'
        },
        ContractEventParamSpecV2: {
            label: 'Text',
            indexed: 'bool',
            type: 'ContractTypeSpec',
            docs: 'Vec<Text>'
        },
        ContractEventSpecV0: {
            name: 'Text',
            args: 'Vec<ContractEventParamSpecV0>',
            docs: 'Vec<Text>'
        },
        ContractEventSpecV1: {
            name: 'Text',
            args: 'Vec<ContractEventParamSpecV0>',
            docs: 'Vec<Text>'
        },
        ContractEventSpecV2: {
            label: 'Text',
            args: 'Vec<ContractEventParamSpecV2>',
            docs: 'Vec<Text>'
        },
        ContractMessageParamSpecV0: {
            name: 'Text',
            type: 'ContractTypeSpec'
        },
        ContractMessageParamSpecV2: {
            label: 'Text',
            type: 'ContractTypeSpec'
        },
        ContractMessageSpecV0: {
            name: 'Text',
            selector: 'ContractSelector',
            mutates: 'bool',
            payable: 'bool',
            args: 'Vec<ContractMessageParamSpecV0>',
            returnType: 'Option<ContractTypeSpec>',
            docs: 'Vec<Text>'
        },
        ContractMessageSpecV1: {
            name: 'Vec<Text>',
            selector: 'ContractSelector',
            mutates: 'bool',
            payable: 'bool',
            args: 'Vec<ContractMessageParamSpecV0>',
            returnType: 'Option<ContractTypeSpec>',
            docs: 'Vec<Text>'
        },
        ContractMessageSpecV2: {
            label: 'Text',
            selector: 'ContractSelector',
            mutates: 'bool',
            payable: 'bool',
            args: 'Vec<ContractMessageParamSpecV2>',
            returnType: 'Option<ContractTypeSpec>',
            docs: 'Vec<Text>'
        },
        ContractMessageSpecV3: {
            label: 'Text',
            selector: 'ContractSelector',
            mutates: 'bool',
            payable: 'bool',
            args: 'Vec<ContractMessageParamSpecV2>',
            returnType: 'Option<ContractTypeSpec>',
            docs: 'Vec<Text>',
            default: 'bool'
        },
        ContractSelector: '[u8; 4]',
        ContractTypeSpec: {
            type: 'SiLookupTypeId',
            displayName: 'ContractDisplayName'
        }
    };
    const latest = {
        ContractConstructorSpecLatest: 'ContractConstructorSpecV4',
        ContractEventSpecLatest: 'ContractEventSpecV2',
        ContractEventParamSpecLatest: 'ContractEventParamSpecV2',
        ContractMessageParamSpecLatest: 'ContractMessageParamSpecV2',
        ContractMessageSpecLatest: 'ContractMessageSpecV3',
        ContractMetadataLatest: 'ContractMetadataV4'
    };
    const definitions$c = {
        rpc: {},
        types: {
            ...layout,
            ...spec,
            ...latest,
            ContractProjectInfo: {
                source: 'ContractProjectSource',
                contract: 'ContractProjectContract'
            },
            ContractMetadataV0: {
                metadataVersion: 'Text',
                types: 'Vec<Si0Type>',
                spec: 'ContractContractSpecV0'
            },
            ContractMetadataV1: {
                types: 'Vec<PortableType>',
                spec: 'ContractContractSpecV1'
            },
            ContractMetadataV2: {
                types: 'Vec<PortableType>',
                spec: 'ContractContractSpecV2'
            },
            ContractMetadataV3: {
                types: 'Vec<PortableType>',
                spec: 'ContractContractSpecV3'
            },
            ContractMetadataV4: {
                types: 'Vec<PortableType>',
                spec: 'ContractContractSpecV4'
            },
            ContractMetadata: {
                _enum: {
                    V0: 'ContractMetadataV0',
                    V1: 'ContractMetadataV1',
                    V2: 'ContractMetadataV2',
                    V3: 'ContractMetadataV3',
                    V4: 'ContractMetadataV4'
                }
            },
            ContractProjectV0: {
                metadataVersion: 'Text',
                source: 'ContractProjectSource',
                contract: 'ContractProjectContract',
                types: 'Vec<Si0Type>',
                spec: 'ContractContractSpecV0'
            },
            ContractProject: '(ContractProjectInfo, ContractMetadata)',
            ContractProjectContract: {
                _alias: {
                    docs: 'documentation'
                },
                name: 'Text',
                version: 'Text',
                authors: 'Vec<Text>',
                description: 'Option<Text>',
                docs: 'Option<Text>',
                repository: 'Option<Text>',
                homepage: 'Option<Text>',
                license: 'Option<Text>'
            },
            ContractProjectSource: {
                _alias: {
                    wasmHash: 'hash'
                },
                wasmHash: '[u8; 32]',
                language: 'Text',
                compiler: 'Text',
                wasm: 'Raw'
            },
            ContractEnvironmentV4: {
                _alias: {
                    hashType: 'hash'
                },
                accountId: 'Option<ContractTypeSpec>',
                balance: 'Option<ContractTypeSpec>',
                blockNumber: 'Option<ContractTypeSpec>',
                hashType: 'Option<ContractTypeSpec>',
                timestamp: 'Option<ContractTypeSpec>',
                maxEventTopics: 'Option<u32>'
            }
        }
    };

    const netRpc = {
        listening: {
            aliasSection: 'net',
            description: 'Returns true if client is actively listening for network connections. Otherwise false.',
            params: [],
            type: 'bool'
        },
        peerCount: {
            aliasSection: 'net',
            description: 'Returns number of peers connected to node.',
            params: [],
            type: 'Text'
        },
        version: {
            aliasSection: 'net',
            description: 'Returns protocol version.',
            params: [],
            type: 'Text'
        }
    };
    const web3Rpc = {
        clientVersion: {
            aliasSection: 'web3',
            description: 'Returns current client version.',
            params: [],
            type: 'Text'
        },
        sha3: {
            aliasSection: 'web3',
            description: 'Returns sha3 of the given data',
            params: [{ name: 'data', type: 'Bytes' }],
            type: 'H256'
        }
    };
    const rpc$7 = {
        ...netRpc,
        ...web3Rpc,
        accounts: {
            description: 'Returns accounts list.',
            params: [],
            type: 'Vec<H160>'
        },
        blockNumber: {
            description: 'Returns the blockNumber',
            params: [],
            type: 'U256'
        },
        call: {
            description: 'Call contract, returning the output data.',
            params: [
                {
                    name: 'request',
                    type: 'EthCallRequest'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'number',
                    type: 'BlockNumber'
                }
            ],
            type: 'Bytes'
        },
        chainId: {
            description: 'Returns the chain ID used for transaction signing at the current best block. None is returned if not available.',
            params: [],
            type: 'U64'
        },
        coinbase: {
            description: 'Returns block author.',
            params: [],
            type: 'H160'
        },
        estimateGas: {
            description: 'Estimate gas needed for execution of given contract.',
            params: [
                {
                    name: 'request',
                    type: 'EthCallRequest'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'number',
                    type: 'BlockNumber'
                }
            ],
            type: 'U256'
        },
        feeHistory: {
            description: 'Returns fee history for given block count & reward percentiles',
            params: [
                {
                    name: 'blockCount',
                    type: 'U256'
                },
                {
                    name: 'newestBlock',
                    type: 'BlockNumber'
                },
                {
                    name: 'rewardPercentiles',
                    type: 'Option<Vec<f64>>'
                }
            ],
            type: 'EthFeeHistory'
        },
        gasPrice: {
            description: 'Returns current gas price.',
            params: [],
            type: 'U256'
        },
        getBalance: {
            description: 'Returns balance of the given account.',
            params: [
                {
                    name: 'address',
                    type: 'H160'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'number',
                    type: 'BlockNumber'
                }
            ],
            type: 'U256'
        },
        getBlockByHash: {
            description: 'Returns block with given hash.',
            params: [
                {
                    name: 'hash',
                    type: 'H256'
                },
                {
                    name: 'full',
                    type: 'bool'
                }
            ],
            type: 'Option<EthRichBlock>'
        },
        getBlockByNumber: {
            description: 'Returns block with given number.',
            params: [
                {
                    name: 'block',
                    type: 'BlockNumber'
                },
                { name: 'full', type: 'bool' }
            ],
            type: 'Option<EthRichBlock>'
        },
        getBlockTransactionCountByHash: {
            description: 'Returns the number of transactions in a block with given hash.',
            params: [
                {
                    name: 'hash',
                    type: 'H256'
                }
            ],
            type: 'U256'
        },
        getBlockTransactionCountByNumber: {
            description: 'Returns the number of transactions in a block with given block number.',
            params: [
                {
                    name: 'block',
                    type: 'BlockNumber'
                }
            ],
            type: 'U256'
        },
        getCode: {
            description: 'Returns the code at given address at given time (block number).',
            params: [
                {
                    name: 'address',
                    type: 'H160'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'number',
                    type: 'BlockNumber'
                }
            ],
            type: 'Bytes'
        },
        getFilterChanges: {
            description: 'Returns filter changes since last poll.',
            params: [
                {
                    name: 'index',
                    type: 'U256'
                }
            ],
            type: 'EthFilterChanges'
        },
        getFilterLogs: {
            description: 'Returns all logs matching given filter (in a range \'from\' - \'to\').',
            params: [
                {
                    name: 'index',
                    type: 'U256'
                }
            ],
            type: 'Vec<EthLog>'
        },
        getLogs: {
            description: 'Returns logs matching given filter object.',
            params: [
                {
                    name: 'filter',
                    type: 'EthFilter'
                }
            ],
            type: 'Vec<EthLog>'
        },
        getProof: {
            description: 'Returns proof for account and storage.',
            params: [
                {
                    name: 'address',
                    type: 'H160'
                },
                {
                    name: 'storageKeys',
                    type: 'Vec<H256>'
                },
                {
                    name: 'number',
                    type: 'BlockNumber'
                }
            ],
            type: 'EthAccount'
        },
        getStorageAt: {
            description: 'Returns content of the storage at given address.',
            params: [
                {
                    name: 'address',
                    type: 'H160'
                },
                {
                    name: 'index',
                    type: 'U256'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'number',
                    type: 'BlockNumber'
                }
            ],
            type: 'H256'
        },
        getTransactionByBlockHashAndIndex: {
            description: 'Returns transaction at given block hash and index.',
            params: [
                {
                    name: 'hash',
                    type: 'H256'
                },
                {
                    name: 'index',
                    type: 'U256'
                }
            ],
            type: 'EthTransaction'
        },
        getTransactionByBlockNumberAndIndex: {
            description: 'Returns transaction by given block number and index.',
            params: [
                {
                    name: 'number',
                    type: 'BlockNumber'
                },
                {
                    name: 'index',
                    type: 'U256'
                }
            ],
            type: 'EthTransaction'
        },
        getTransactionByHash: {
            description: 'Get transaction by its hash.',
            params: [
                {
                    name: 'hash',
                    type: 'H256'
                }
            ],
            type: 'EthTransaction'
        },
        getTransactionCount: {
            description: 'Returns the number of transactions sent from given address at given time (block number).',
            params: [
                {
                    name: 'address',
                    type: 'H160'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'number',
                    type: 'BlockNumber'
                }
            ],
            type: 'U256'
        },
        getTransactionReceipt: {
            description: 'Returns transaction receipt by transaction hash.',
            params: [
                {
                    name: 'hash',
                    type: 'H256'
                }
            ],
            type: 'EthReceipt'
        },
        getUncleByBlockHashAndIndex: {
            description: 'Returns an uncles at given block and index.',
            params: [
                {
                    name: 'hash',
                    type: 'H256'
                },
                {
                    name: 'index',
                    type: 'U256'
                }
            ],
            type: 'EthRichBlock'
        },
        getUncleByBlockNumberAndIndex: {
            description: 'Returns an uncles at given block and index.',
            params: [
                {
                    name: 'number',
                    type: 'BlockNumber'
                },
                {
                    name: 'index',
                    type: 'U256'
                }
            ],
            type: 'EthRichBlock'
        },
        getUncleCountByBlockHash: {
            description: 'Returns the number of uncles in a block with given hash.',
            params: [
                {
                    name: 'hash',
                    type: 'H256'
                }
            ],
            type: 'U256'
        },
        getUncleCountByBlockNumber: {
            description: 'Returns the number of uncles in a block with given block number.',
            params: [
                {
                    name: 'number',
                    type: 'BlockNumber'
                }
            ],
            type: 'U256'
        },
        getWork: {
            description: 'Returns the hash of the current block, the seedHash, and the boundary condition to be met.',
            params: [],
            type: 'EthWork'
        },
        hashrate: {
            description: 'Returns the number of hashes per second that the node is mining with.',
            params: [],
            type: 'U256'
        },
        maxPriorityFeePerGas: {
            description: 'Returns max priority fee per gas',
            params: [],
            type: 'U256'
        },
        mining: {
            description: 'Returns true if client is actively mining new blocks.',
            params: [],
            type: 'bool'
        },
        newBlockFilter: {
            description: 'Returns id of new block filter.',
            params: [],
            type: 'U256'
        },
        newFilter: {
            description: 'Returns id of new filter.',
            params: [
                {
                    name: 'filter',
                    type: 'EthFilter'
                }
            ],
            type: 'U256'
        },
        newPendingTransactionFilter: {
            description: 'Returns id of new block filter.',
            params: [],
            type: 'U256'
        },
        protocolVersion: {
            description: 'Returns protocol version encoded as a string (quotes are necessary).',
            params: [],
            type: 'u64'
        },
        sendRawTransaction: {
            description: 'Sends signed transaction, returning its hash.',
            params: [
                {
                    name: 'bytes',
                    type: 'Bytes'
                }
            ],
            type: 'H256'
        },
        sendTransaction: {
            description: 'Sends transaction; will block waiting for signer to return the transaction hash',
            params: [
                {
                    name: 'tx',
                    type: 'EthTransactionRequest'
                }
            ],
            type: 'H256'
        },
        submitHashrate: {
            description: 'Used for submitting mining hashrate.',
            params: [
                {
                    name: 'index',
                    type: 'U256'
                },
                {
                    name: 'hash',
                    type: 'H256'
                }
            ],
            type: 'bool'
        },
        submitWork: {
            description: 'Used for submitting a proof-of-work solution.',
            params: [
                {
                    name: 'nonce',
                    type: 'H64'
                },
                {
                    name: 'headerHash',
                    type: 'H256'
                },
                {
                    name: 'mixDigest',
                    type: 'H256'
                }
            ],
            type: 'bool'
        },
        subscribe: {
            description: 'Subscribe to Eth subscription.',
            params: [
                { name: 'kind', type: 'EthSubKind' },
                {
                    isOptional: true,
                    name: 'params',
                    type: 'EthSubParams'
                }
            ],
            pubsub: [
                'subscription',
                'subscribe',
                'unsubscribe'
            ],
            type: 'Null'
        },
        syncing: {
            description: 'Returns an object with data about the sync status or false.',
            params: [],
            type: 'EthSyncStatus'
        },
        uninstallFilter: {
            description: 'Uninstalls filter.',
            params: [
                {
                    name: 'index',
                    type: 'U256'
                }
            ],
            type: 'bool'
        }
    };

    const ethMethodsV4 = {
        account_basic: {
            description: 'Returns pallet_evm::Accounts by address.',
            params: [
                {
                    name: 'address',
                    type: 'H160'
                }
            ],
            type: 'EvmAccount'
        },
        account_code_at: {
            description: 'For a given account address, returns pallet_evm::AccountCodes.',
            params: [
                {
                    name: 'address',
                    type: 'H160'
                }
            ],
            type: 'Bytes'
        },
        author: {
            description: 'Returns the converted FindAuthor::find_author authority id.',
            params: [],
            type: 'H160'
        },
        call: {
            description: 'Returns a frame_ethereum::call response. If `estimate` is true,',
            params: [
                {
                    name: 'from',
                    type: 'H160'
                },
                {
                    name: 'to',
                    type: 'H160'
                },
                {
                    name: 'data',
                    type: 'Vec<u8>'
                },
                {
                    name: 'value',
                    type: 'U256'
                },
                {
                    name: 'gasLimit',
                    type: 'U256'
                },
                {
                    name: 'maxFeePerGas',
                    type: 'Option<U256>'
                },
                {
                    name: 'maxPriorityFeePerGas',
                    type: 'Option<U256>'
                },
                {
                    name: 'nonce',
                    type: 'Option<U256>'
                },
                {
                    name: 'estimate',
                    type: 'bool'
                },
                {
                    name: 'accessList',
                    type: 'Option<Vec<(H160, Vec<H256>)>>'
                }
            ],
            type: 'Result<EvmCallInfo, DispatchError>'
        },
        chain_id: {
            description: 'Returns runtime defined pallet_evm::ChainId.',
            params: [],
            type: 'u64'
        },
        create: {
            description: 'Returns a frame_ethereum::call response. If `estimate` is true,',
            params: [
                {
                    name: 'from',
                    type: 'H160'
                },
                {
                    name: 'data',
                    type: 'Vec<u8>'
                },
                {
                    name: 'value',
                    type: 'U256'
                },
                {
                    name: 'gasLimit',
                    type: 'U256'
                },
                {
                    name: 'maxFeePerGas',
                    type: 'Option<U256>'
                },
                {
                    name: 'maxPriorityFeePerGas',
                    type: 'Option<U256>'
                },
                {
                    name: 'nonce',
                    type: 'Option<U256>'
                },
                {
                    name: 'estimate',
                    type: 'bool'
                },
                {
                    name: 'accessList',
                    type: 'Option<Vec<(H160, Vec<H256>)>>'
                }
            ],
            type: 'Result<EvmCreateInfo, DispatchError>'
        },
        current_all: {
            description: 'Return all the current data for a block in a single runtime call.',
            params: [],
            type: '(Option<BlockV2>, Option<Vec<EthReceiptV3>>, Option<Vec<EthTransactionStatus>>)'
        },
        current_block: {
            description: 'Return the current block.',
            params: [],
            type: 'BlockV2'
        },
        current_receipts: {
            description: 'Return the current receipt.',
            params: [],
            type: 'Option<Vec<EthReceiptV3>>'
        },
        current_transaction_statuses: {
            description: 'Return the current transaction status.',
            params: [],
            type: 'Option<Vec<EthTransactionStatus>>'
        },
        elasticity: {
            description: 'Return the elasticity multiplier.',
            params: [],
            type: 'Option<Permill>'
        },
        extrinsic_filter: {
            description: 'Receives a `Vec<OpaqueExtrinsic>` and filters all the ethereum transactions.',
            params: [
                {
                    name: 'xts',
                    type: 'Vec<Extrinsic>'
                }
            ],
            type: 'Vec<TransactionV2>'
        },
        gas_price: {
            description: 'Returns FixedGasPrice::min_gas_price',
            params: [],
            type: 'u256'
        },
        storage_at: {
            description: 'For a given account address and index, returns pallet_evm::AccountStorages.',
            params: [
                {
                    name: 'address',
                    type: 'H160'
                },
                {
                    name: 'index',
                    type: 'u256'
                }
            ],
            type: 'H256'
        }
    };
    const ethMethodsV5 = {
        call: {
            description: 'Returns a frame_ethereum::call response. If `estimate` is true,',
            params: [
                {
                    name: 'from',
                    type: 'H160'
                },
                {
                    name: 'to',
                    type: 'H160'
                },
                {
                    name: 'data',
                    type: 'Vec<u8>'
                },
                {
                    name: 'value',
                    type: 'U256'
                },
                {
                    name: 'gasLimit',
                    type: 'U256'
                },
                {
                    name: 'maxFeePerGas',
                    type: 'Option<U256>'
                },
                {
                    name: 'maxPriorityFeePerGas',
                    type: 'Option<U256>'
                },
                {
                    name: 'nonce',
                    type: 'Option<U256>'
                },
                {
                    name: 'estimate',
                    type: 'bool'
                },
                {
                    name: 'accessList',
                    type: 'Option<Vec<(H160, Vec<H256>)>>'
                }
            ],
            type: 'Result<EvmCallInfoV2, DispatchError>'
        },
        create: {
            description: 'Returns a frame_ethereum::call response. If `estimate` is true,',
            params: [
                {
                    name: 'from',
                    type: 'H160'
                },
                {
                    name: 'data',
                    type: 'Vec<u8>'
                },
                {
                    name: 'value',
                    type: 'U256'
                },
                {
                    name: 'gasLimit',
                    type: 'U256'
                },
                {
                    name: 'maxFeePerGas',
                    type: 'Option<U256>'
                },
                {
                    name: 'maxPriorityFeePerGas',
                    type: 'Option<U256>'
                },
                {
                    name: 'nonce',
                    type: 'Option<U256>'
                },
                {
                    name: 'estimate',
                    type: 'bool'
                },
                {
                    name: 'accessList',
                    type: 'Option<Vec<(H160, Vec<H256>)>>'
                }
            ],
            type: 'Result<EvmCreateInfoV2, DispatchError>'
        }
    };
    const runtime$5 = {
        ConvertTransactionRuntimeApi: [
            {
                methods: {
                    convert_transaction: {
                        description: 'Converts an Ethereum-style transaction to Extrinsic',
                        params: [
                            {
                                name: 'transaction',
                                type: 'TransactionV2'
                            }
                        ],
                        type: 'Extrinsic'
                    }
                },
                version: 2
            }
        ],
        DebugRuntimeApi: [
            {
                methods: {
                    trace_block: {
                        description: 'Trace all block extrinsics',
                        params: [
                            {
                                name: 'extrinsics',
                                type: 'Vec<Extrinsic>'
                            },
                            {
                                name: 'knownTransactions',
                                type: 'Vec<H256>'
                            }
                        ],
                        type: 'Result<(), DispatchError>'
                    },
                    trace_transaction: {
                        description: 'Trace transaction extrinsics',
                        params: [
                            {
                                name: 'extrinsics',
                                type: 'Vec<Extrinsic>'
                            },
                            {
                                name: 'transaction',
                                type: 'EthTransaction'
                            }
                        ],
                        type: 'Result<(), DispatchError>'
                    }
                },
                version: 4
            }
        ],
        EthereumRuntimeRPCApi: [
            {
                methods: {
                    ...ethMethodsV4
                },
                version: 4
            },
            {
                methods: {
                    ...ethMethodsV4,
                    ...ethMethodsV5
                },
                version: 5
            }
        ]
    };

    const V0 = {
        BlockV0: {
            header: 'EthHeader',
            transactions: 'Vec<TransactionV0>',
            ommers: 'Vec<EthHeader>'
        },
        LegacyTransaction: {
            nonce: 'U256',
            gasPrice: 'U256',
            gasLimit: 'U256',
            action: 'EthTransactionAction',
            value: 'U256',
            input: 'Bytes',
            signature: 'EthTransactionSignature'
        },
        TransactionV0: 'LegacyTransaction'
    };
    const V1 = {
        BlockV1: {
            header: 'EthHeader',
            transactions: 'Vec<TransactionV1>',
            ommers: 'Vec<EthHeader>'
        },
        EIP2930Transaction: {
            chainId: 'u64',
            nonce: 'U256',
            gasPrice: 'U256',
            gasLimit: 'U256',
            action: 'EthTransactionAction',
            value: 'U256',
            input: 'Bytes',
            accessList: 'EthAccessList',
            oddYParity: 'bool',
            r: 'H256',
            s: 'H256'
        },
        TransactionV1: {
            _enum: {
                Legacy: 'LegacyTransaction',
                EIP2930: 'EIP2930Transaction'
            }
        }
    };
    const V2 = {
        BlockV2: {
            header: 'EthHeader',
            transactions: 'Vec<TransactionV2>',
            ommers: 'Vec<EthHeader>'
        },
        EIP1559Transaction: {
            chainId: 'u64',
            nonce: 'U256',
            maxPriorityFeePerGas: 'U256',
            maxFeePerGas: 'U256',
            gasLimit: 'U256',
            action: 'EthTransactionAction',
            value: 'U256',
            input: 'Bytes',
            accessList: 'EthAccessList',
            oddYParity: 'bool',
            r: 'H256',
            s: 'H256'
        },
        TransactionV2: {
            _enum: {
                Legacy: 'LegacyTransaction',
                EIP2930: 'EIP2930Transaction',
                EIP1559: 'EIP1559Transaction'
            }
        }
    };
    const types = {
        ...V0,
        ...V1,
        ...V2,
        EthereumAccountId: 'GenericEthereumAccountId',
        EthereumAddress: 'GenericEthereumAccountId',
        EthereumLookupSource: 'GenericEthereumLookupSource',
        EthereumSignature: '[u8; 65]',
        EthAccessListItem: {
            address: 'EthAddress',
            slots: 'Vec<H256>'
        },
        EthAccessList: 'Vec<EthAccessListItem>',
        EthAccount: {
            address: 'EthAddress',
            balance: 'U256',
            nonce: 'U256',
            codeHash: 'H256',
            storageHash: 'H256',
            accountProof: 'Vec<Bytes>',
            storageProof: 'Vec<EthStorageProof>'
        },
        EthAddress: 'H160',
        EthBlock: {
            header: 'EthHeader',
            transactions: 'Vec<EthTransaction>',
            ommers: 'Vec<EthHeader>'
        },
        EthHeader: {
            parentHash: 'H256',
            ommersHash: 'H256',
            beneficiary: 'EthAddress',
            stateRoot: 'H256',
            transactionsRoot: 'H256',
            receiptsRoot: 'H256',
            logsBloom: 'EthBloom',
            difficulty: 'U256',
            number: 'U256',
            gasLimit: 'U256',
            gasUsed: 'U256',
            timestamp: 'u64',
            extraData: 'Bytes',
            mixMash: 'H256',
            nonce: 'H64'
        },
        EthRichBlock: {
            _alias: {
                blockHash: 'hash',
                blockSize: 'size'
            },
            blockHash: 'Option<H256>',
            parentHash: 'H256',
            sha3Uncles: 'H256',
            author: 'EthAddress',
            miner: 'EthAddress',
            stateRoot: 'H256',
            transactionsRoot: 'H256',
            receiptsRoot: 'H256',
            number: 'Option<U256>',
            gasUsed: 'U256',
            gasLimit: 'U256',
            extraData: 'Bytes',
            logsBloom: 'EthBloom',
            timestamp: 'U256',
            difficulty: 'U256',
            totalDifficulty: 'Option<U256>',
            sealFields: 'Vec<Bytes>',
            uncles: 'Vec<H256>',
            transactions: 'Vec<EthTransaction>',
            blockSize: 'Option<U256>'
        },
        EthBloom: 'H2048',
        EthCallRequest: {
            from: 'Option<EthAddress>',
            to: 'Option<EthAddress>',
            gasPrice: 'Option<U256>',
            gas: 'Option<U256>',
            value: 'Option<U256>',
            data: 'Option<Bytes>',
            nonce: 'Option<U256>'
        },
        EthFeeHistory: {
            oldestBlock: 'U256',
            baseFeePerGas: 'Vec<U256>',
            gasUsedRatio: 'Vec<f64>',
            reward: 'Option<Vec<Vec<U256>>>'
        },
        EthFilter: {
            fromBlock: 'Option<BlockNumber>',
            toBlock: 'Option<BlockNumber>',
            blockHash: 'Option<H256>',
            address: 'Option<EthFilterAddress>',
            topics: 'Option<EthFilterTopic>'
        },
        EthFilterAddress: {
            _enum: {
                Single: 'EthAddress',
                Multiple: 'Vec<EthAddress>',
                Null: 'Null'
            }
        },
        EthFilterChanges: {
            _enum: {
                Logs: 'Vec<EthLog>',
                Hashes: 'Vec<H256>',
                Empty: 'Null'
            }
        },
        EthFilterTopic: {
            _enum: {
                Single: 'EthFilterTopicInner',
                Multiple: 'Vec<EthFilterTopicInner>',
                Null: 'Null'
            }
        },
        EthFilterTopicEntry: 'Option<H256>',
        EthFilterTopicInner: {
            _enum: {
                Single: 'EthFilterTopicEntry',
                Multiple: 'Vec<EthFilterTopicEntry>',
                Null: 'Null'
            }
        },
        EthRichHeader: {
            _alias: {
                blockHash: 'hash',
                blockSize: 'size'
            },
            blockHash: 'Option<H256>',
            parentHash: 'H256',
            sha3Uncles: 'H256',
            author: 'EthAddress',
            miner: 'EthAddress',
            stateRoot: 'H256',
            transactionsRoot: 'H256',
            receiptsRoot: 'H256',
            number: 'Option<U256>',
            gasUsed: 'U256',
            gasLimit: 'U256',
            extraData: 'Bytes',
            logsBloom: 'EthBloom',
            timestamp: 'U256',
            difficulty: 'U256',
            sealFields: 'Vec<Bytes>',
            blockSize: 'Option<U256>'
        },
        EthLog: {
            address: 'EthAddress',
            topics: 'Vec<H256>',
            data: 'Bytes',
            blockHash: 'Option<H256>',
            blockNumber: 'Option<U256>',
            transactionHash: 'Option<H256>',
            transactionIndex: 'Option<U256>',
            logIndex: 'Option<U256>',
            transactionLogIndex: 'Option<U256>',
            removed: 'bool'
        },
        EthReceipt: {
            transactionHash: 'Option<H256>',
            transactionIndex: 'Option<U256>',
            blockHash: 'Option<H256>',
            from: 'Option<EthAddress>',
            to: 'Option<EthAddress>',
            blockNumber: 'Option<U256>',
            cumulativeGasUsed: 'U256',
            gasUsed: 'Option<U256>',
            contractAddress: 'Option<EthAddress>',
            logs: 'Vec<EthLog>',
            root: 'Option<H256>',
            logsBloom: 'EthBloom',
            statusCode: 'Option<U64>'
        },
        EthReceiptV0: 'EthReceipt',
        EthReceiptV3: 'EthReceipt',
        EthStorageProof: {
            key: 'U256',
            value: 'U256',
            proof: 'Vec<Bytes>'
        },
        EthSubKind: {
            _enum: ['newHeads', 'logs', 'newPendingTransactions', 'syncing']
        },
        EthSubParams: {
            _enum: {
                None: 'Null',
                Logs: 'EthFilter'
            }
        },
        EthSubResult: {
            _enum: {
                Header: 'EthRichHeader',
                Log: 'EthLog',
                TransactionHash: 'H256',
                SyncState: 'EthSyncStatus'
            }
        },
        EthSyncInfo: {
            startingBlock: 'U256',
            currentBlock: 'U256',
            highestBlock: 'U256',
            warpChunksAmount: 'Option<U256>',
            warpChunksProcessed: 'Option<U256>'
        },
        EthSyncStatus: {
            _enum: {
                Info: 'EthSyncInfo',
                None: 'Null'
            }
        },
        EthTransaction: {
            hash: 'H256',
            nonce: 'U256',
            blockHash: 'Option<H256>',
            blockNumber: 'Option<U256>',
            transactionIndex: 'Option<U256>',
            from: 'H160',
            to: 'Option<H160>',
            value: 'U256',
            gasPrice: 'Option<U256>',
            maxFeePerGas: 'Option<U256>',
            maxPriorityFeePerGas: 'Option<U256>',
            gas: 'U256',
            input: 'Bytes',
            creates: 'Option<H160>',
            raw: 'Bytes',
            publicKey: 'Option<H512>',
            chainId: 'Option<U64>',
            standardV: 'U256',
            v: 'U256',
            r: 'U256',
            s: 'U256',
            accessList: 'Option<Vec<EthAccessListItem>>',
            transactionType: 'Option<U256>'
        },
        EthTransactionSignature: {
            v: 'u64',
            r: 'H256',
            s: 'H256'
        },
        EthTransactionAction: {
            _enum: {
                Call: 'H160',
                Create: 'Null'
            }
        },
        EthTransactionCondition: {
            _enum: {
                block: 'u64',
                time: 'u64'
            }
        },
        EthTransactionRequest: {
            from: 'Option<EthAddress>',
            to: 'Option<EthAddress>',
            gasPrice: 'Option<U256>',
            gas: 'Option<U256>',
            value: 'Option<U256>',
            data: 'Option<Bytes>',
            nonce: 'Option<U256>'
        },
        EthTransactionStatus: {
            transactionHash: 'H256',
            transactionIndex: 'u32',
            from: 'EthAddress',
            to: 'Option<EthAddress>',
            contractAddress: 'Option<EthAddress>',
            logs: 'Vec<EthLog>',
            logsBloom: 'EthBloom'
        },
        EthWork: {
            powHash: 'H256',
            seedHash: 'H256',
            target: 'H256',
            number: 'Option<u64>'
        }
    };
    const definitions$b = { rpc: rpc$7, runtime: runtime$5, types };

    const runtime$4 = {
        AuthorFilterAPI: [
            {
                methods: {
                    can_author: {
                        description: 'The runtime api used to predict whether an author will be eligible in the given slot',
                        params: [
                            {
                                name: 'author',
                                type: 'AccountId'
                            },
                            {
                                name: 'relayParent',
                                type: 'u32'
                            },
                            {
                                name: 'parentHeader',
                                type: 'Header'
                            }
                        ],
                        type: 'bool'
                    }
                },
                version: 2
            },
            {
                methods: {
                    can_author: {
                        description: 'The runtime api used to predict whether an author will be eligible in the given slot',
                        params: [
                            {
                                name: 'author',
                                type: 'AccountId'
                            },
                            {
                                name: 'relayParent',
                                type: 'u32'
                            }
                        ],
                        type: 'bool'
                    }
                },
                version: 1
            }
        ],
        NimbusApi: [
            {
                methods: {
                    can_author: {
                        description: 'The runtime api used to predict whether a Nimbus author will be eligible in the given slot',
                        params: [
                            {
                                name: 'author',
                                type: 'AccountId'
                            },
                            {
                                name: 'relayParent',
                                type: 'u32'
                            },
                            {
                                name: 'parentHeader',
                                type: 'Header'
                            }
                        ],
                        type: 'bool'
                    }
                },
                version: 1
            }
        ]
    };

    const definitions$a = {
        rpc: {},
        runtime: runtime$4,
        types: {}
    };

    const runtime$3 = {
        OracleApi: [
            {
                methods: {
                    get_all_values: {
                        description: 'Retrieves all values',
                        params: [
                            {
                                name: 'providerId',
                                type: 'Raw'
                            }
                        ],
                        type: 'Raw'
                    },
                    get_value: {
                        description: 'Retrieves a single value',
                        params: [
                            {
                                name: 'providerId',
                                type: 'Raw'
                            },
                            {
                                name: 'key',
                                type: 'Raw'
                            }
                        ],
                        type: 'Option<Raw>'
                    }
                },
                version: 1
            }
        ]
    };

    const definitions$9 = {
        rpc: {},
        runtime: runtime$3,
        types: {}
    };

    const runtime$2 = {
        TokensApi: [
            {
                methods: {
                    query_existential_deposit: {
                        description: 'Query the existential amount for a specific currency',
                        params: [
                            {
                                name: 'currencyId',
                                type: 'Raw'
                            }
                        ],
                        type: 'u128'
                    }
                },
                version: 1
            }
        ]
    };

    const definitions$8 = {
        rpc: {},
        runtime: runtime$2,
        types: {}
    };

    const rpc$6 = {
        methods: {
            description: 'Retrieves the list of RPC methods that are exposed by the node',
            params: [],
            type: 'RpcMethods'
        }
    };

    const definitions$7 = {
        rpc: rpc$6,
        types: {
            RpcMethods: {
                version: 'u32',
                methods: 'Vec<Text>'
            }
        }
    };

    const rpc$5 = {
        hasKey: {
            description: 'Returns true if the keystore has private keys for the given public key and key type.',
            isUnsafe: true,
            params: [
                {
                    name: 'publicKey',
                    type: 'Bytes'
                },
                {
                    name: 'keyType',
                    type: 'Text'
                }
            ],
            type: 'bool'
        },
        hasSessionKeys: {
            description: 'Returns true if the keystore has private keys for the given session public keys.',
            isUnsafe: true,
            params: [
                {
                    name: 'sessionKeys',
                    type: 'Bytes'
                }
            ],
            type: 'bool'
        },
        insertKey: {
            description: 'Insert a key into the keystore.',
            isUnsafe: true,
            params: [
                {
                    name: 'keyType',
                    type: 'Text'
                },
                {
                    name: 'suri',
                    type: 'Text'
                },
                {
                    name: 'publicKey',
                    type: 'Bytes'
                }
            ],
            type: 'Bytes'
        },
        pendingExtrinsics: {
            description: 'Returns all pending extrinsics, potentially grouped by sender',
            params: [],
            type: 'Vec<Extrinsic>'
        },
        removeExtrinsic: {
            description: 'Remove given extrinsic from the pool and temporarily ban it to prevent reimporting',
            isUnsafe: true,
            params: [
                {
                    name: 'bytesOrHash',
                    type: 'Vec<ExtrinsicOrHash>'
                }
            ],
            type: 'Vec<Hash>'
        },
        rotateKeys: {
            description: 'Generate new session keys and returns the corresponding public keys',
            isUnsafe: true,
            params: [],
            type: 'Bytes'
        },
        submitAndWatchExtrinsic: {
            description: 'Submit and subscribe to watch an extrinsic until unsubscribed',
            isSigned: true,
            params: [
                {
                    name: 'extrinsic',
                    type: 'Extrinsic'
                }
            ],
            pubsub: [
                'extrinsicUpdate',
                'submitAndWatchExtrinsic',
                'unwatchExtrinsic'
            ],
            type: 'ExtrinsicStatus'
        },
        submitExtrinsic: {
            description: 'Submit a fully formatted extrinsic for block inclusion',
            isSigned: true,
            params: [
                {
                    name: 'extrinsic',
                    type: 'Extrinsic'
                }
            ],
            type: 'Hash'
        }
    };

    const definitions$6 = {
        rpc: rpc$5,
        types: {
            ExtrinsicOrHash: {
                _enum: {
                    Hash: 'Hash',
                    Extrinsic: 'Bytes'
                }
            },
            ExtrinsicStatus: {
                _enum: {
                    Future: 'Null',
                    Ready: 'Null',
                    Broadcast: 'Vec<Text>',
                    InBlock: 'Hash',
                    Retracted: 'Hash',
                    FinalityTimeout: 'Hash',
                    Finalized: 'Hash',
                    Usurped: 'Hash',
                    Dropped: 'Null',
                    Invalid: 'Null'
                }
            }
        }
    };

    const rpc$4 = {
        getBlock: {
            description: 'Get header and body of a relay chain block',
            params: [
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'hash',
                    type: 'BlockHash'
                }
            ],
            type: 'SignedBlock'
        },
        getBlockHash: {
            description: 'Get the block hash for a specific block',
            params: [
                {
                    isOptional: true,
                    name: 'blockNumber',
                    type: 'BlockNumber'
                }
            ],
            type: 'BlockHash'
        },
        getFinalizedHead: {
            alias: ['chain_getFinalisedHead'],
            description: 'Get hash of the last finalized block in the canon chain',
            params: [],
            type: 'BlockHash'
        },
        getHeader: {
            alias: ['chain_getHead'],
            description: 'Retrieves the header for a specific block',
            params: [
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'hash',
                    type: 'BlockHash'
                }
            ],
            type: 'Header'
        },
        subscribeAllHeads: {
            description: 'Retrieves the newest header via subscription',
            params: [],
            pubsub: [
                'allHead',
                'subscribeAllHeads',
                'unsubscribeAllHeads'
            ],
            type: 'Header'
        },
        subscribeFinalizedHeads: {
            alias: ['chain_subscribeFinalisedHeads', 'chain_unsubscribeFinalisedHeads'],
            description: 'Retrieves the best finalized header via subscription',
            params: [],
            pubsub: [
                'finalizedHead',
                'subscribeFinalizedHeads',
                'unsubscribeFinalizedHeads'
            ],
            type: 'Header'
        },
        subscribeNewHeads: {
            alias: ['chain_unsubscribeNewHeads', 'subscribe_newHead', 'unsubscribe_newHead'],
            description: 'Retrieves the best header via subscription',
            params: [],
            pubsub: [
                'newHead',
                'subscribeNewHead',
                'unsubscribeNewHead'
            ],
            type: 'Header'
        }
    };

    const definitions$5 = {
        rpc: rpc$4,
        types: {
            BlockHash: 'Hash'
        }
    };

    const rpc$3 = {
        getKeys: {
            description: 'Returns the keys with prefix from a child storage, leave empty to get all the keys',
            params: [
                {
                    name: 'childKey',
                    type: 'PrefixedStorageKey'
                },
                {
                    name: 'prefix',
                    type: 'StorageKey'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'Hash'
                }
            ],
            type: 'Vec<StorageKey>'
        },
        getKeysPaged: {
            alias: ['childstate_getKeysPagedAt'],
            description: 'Returns the keys with prefix from a child storage with pagination support',
            params: [
                {
                    name: 'childKey',
                    type: 'PrefixedStorageKey'
                },
                {
                    name: 'prefix',
                    type: 'StorageKey'
                },
                {
                    name: 'count',
                    type: 'u32'
                },
                {
                    isOptional: true,
                    name: 'startKey',
                    type: 'StorageKey'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'Hash'
                }
            ],
            type: 'Vec<StorageKey>'
        },
        getStorage: {
            description: 'Returns a child storage entry at a specific block state',
            params: [
                {
                    name: 'childKey',
                    type: 'PrefixedStorageKey'
                },
                {
                    name: 'key',
                    type: 'StorageKey'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'Hash'
                }
            ],
            type: 'Option<StorageData>'
        },
        getStorageEntries: {
            description: 'Returns child storage entries for multiple keys at a specific block state',
            params: [
                {
                    name: 'childKey',
                    type: 'PrefixedStorageKey'
                },
                {
                    name: 'keys',
                    type: 'Vec<StorageKey>'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'Hash'
                }
            ],
            type: 'Vec<Option<StorageData>>'
        },
        getStorageHash: {
            description: 'Returns the hash of a child storage entry at a block state',
            params: [
                {
                    name: 'childKey',
                    type: 'PrefixedStorageKey'
                },
                {
                    name: 'key',
                    type: 'StorageKey'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'Hash'
                }
            ],
            type: 'Option<Hash>'
        },
        getStorageSize: {
            description: 'Returns the size of a child storage entry at a block state',
            params: [
                {
                    name: 'childKey',
                    type: 'PrefixedStorageKey'
                },
                {
                    name: 'key',
                    type: 'StorageKey'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'Hash'
                }
            ],
            type: 'Option<u64>'
        }
    };

    const definitions$4 = {
        rpc: rpc$3,
        types: {
            PrefixedStorageKey: 'StorageKey'
        }
    };

    const rpc$2 = {
        localStorageGet: {
            description: 'Get offchain local storage under given key and prefix',
            isUnsafe: true,
            params: [
                {
                    name: 'kind',
                    type: 'StorageKind'
                },
                {
                    name: 'key',
                    type: 'Bytes'
                }
            ],
            type: 'Option<Bytes>'
        },
        localStorageSet: {
            description: 'Set offchain local storage under given key and prefix',
            isUnsafe: true,
            params: [
                {
                    name: 'kind',
                    type: 'StorageKind'
                },
                {
                    name: 'key',
                    type: 'Bytes'
                },
                {
                    name: 'value',
                    type: 'Bytes'
                }
            ],
            type: 'Null'
        }
    };

    const runtime$1 = {
        OffchainWorkerApi: [
            {
                methods: {
                    offchain_worker: {
                        description: 'Starts the off-chain task for given block header.',
                        params: [
                            {
                                name: 'header',
                                type: 'Header'
                            }
                        ],
                        type: 'Null'
                    }
                },
                version: 2
            },
            {
                methods: {
                    offchain_worker: {
                        description: 'Starts the off-chain task for given block header.',
                        params: [
                            {
                                name: 'number',
                                type: 'BlockNumber'
                            }
                        ],
                        type: 'Null'
                    }
                },
                version: 1
            }
        ]
    };

    const definitions$3 = {
        rpc: rpc$2,
        runtime: runtime$1,
        types: {
            StorageKind: {
                _enum: {
                    PERSISTENT: 1,
                    LOCAL: 2
                }
            }
        }
    };

    const rpc$1 = {
        queryFeeDetails: {
            deprecated: 'Use `api.call.transactionPaymentApi.queryFeeDetails` instead',
            description: 'Query the detailed fee of a given encoded extrinsic',
            params: [
                {
                    name: 'extrinsic',
                    type: 'Bytes'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'FeeDetails'
        },
        queryInfo: {
            deprecated: 'Use `api.call.transactionPaymentApi.queryInfo` instead',
            description: 'Retrieves the fee information for an encoded extrinsic',
            params: [
                {
                    name: 'extrinsic',
                    type: 'Bytes'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'RuntimeDispatchInfoV1'
        }
    };

    const V1_TO_V4_SHARED_PAY = {
        query_fee_details: {
            description: 'The transaction fee details',
            params: [
                {
                    name: 'uxt',
                    type: 'Extrinsic'
                },
                {
                    name: 'len',
                    type: 'u32'
                }
            ],
            type: 'FeeDetails'
        }
    };
    const V1_TO_V3_SHARED_CALL = {
        query_call_fee_details: {
            description: 'The call fee details',
            params: [
                {
                    name: 'call',
                    type: 'Call'
                },
                {
                    name: 'len',
                    type: 'u32'
                }
            ],
            type: 'FeeDetails'
        }
    };
    const V2_TO_V4_SHARED_PAY = {
        query_info: {
            description: 'The transaction info',
            params: [
                {
                    name: 'uxt',
                    type: 'Extrinsic'
                },
                {
                    name: 'len',
                    type: 'u32'
                }
            ],
            type: 'RuntimeDispatchInfo'
        }
    };
    const V2_V3_SHARED_CALL = {
        query_call_info: {
            description: 'The call info',
            params: [
                {
                    name: 'call',
                    type: 'Call'
                },
                {
                    name: 'len',
                    type: 'u32'
                }
            ],
            type: 'RuntimeDispatchInfo'
        }
    };
    const V3_SHARED_PAY_CALL = {
        query_length_to_fee: {
            description: 'Query the output of the current LengthToFee given some input',
            params: [
                {
                    name: 'length',
                    type: 'u32'
                }
            ],
            type: 'Balance'
        },
        query_weight_to_fee: {
            description: 'Query the output of the current WeightToFee given some input',
            params: [
                {
                    name: 'weight',
                    type: 'Weight'
                }
            ],
            type: 'Balance'
        }
    };
    const runtime = {
        TransactionPaymentApi: [
            {
                methods: {
                    ...V3_SHARED_PAY_CALL,
                    ...V2_TO_V4_SHARED_PAY,
                    ...V1_TO_V4_SHARED_PAY
                },
                version: 4
            },
            {
                methods: {
                    ...V3_SHARED_PAY_CALL,
                    ...V2_TO_V4_SHARED_PAY,
                    ...V1_TO_V4_SHARED_PAY
                },
                version: 3
            },
            {
                methods: {
                    ...V2_TO_V4_SHARED_PAY,
                    ...V1_TO_V4_SHARED_PAY
                },
                version: 2
            },
            {
                methods: {
                    query_info: {
                        description: 'The transaction info',
                        params: [
                            {
                                name: 'uxt',
                                type: 'Extrinsic'
                            },
                            {
                                name: 'len',
                                type: 'u32'
                            }
                        ],
                        type: 'RuntimeDispatchInfo'
                    },
                    ...V1_TO_V4_SHARED_PAY
                },
                version: 1
            }
        ],
        TransactionPaymentCallApi: [
            {
                methods: {
                    ...V3_SHARED_PAY_CALL,
                    ...V2_V3_SHARED_CALL,
                    ...V1_TO_V3_SHARED_CALL
                },
                version: 3
            },
            {
                methods: {
                    ...V2_V3_SHARED_CALL,
                    ...V1_TO_V3_SHARED_CALL
                },
                version: 2
            },
            {
                methods: {
                    CALL: {
                        description: 'The call info',
                        params: [
                            {
                                name: 'call',
                                type: 'Call'
                            },
                            {
                                name: 'len',
                                type: 'u32'
                            }
                        ],
                        type: 'RuntimeDispatchInfo'
                    },
                    ...V1_TO_V3_SHARED_CALL
                },
                version: 1
            }
        ]
    };

    const definitions$2 = {
        rpc: rpc$1,
        runtime,
        types: {
            FeeDetails: {
                inclusionFee: 'Option<InclusionFee>'
            },
            InclusionFee: {
                baseFee: 'Balance',
                lenFee: 'Balance',
                adjustedWeightFee: 'Balance'
            },
            RuntimeDispatchInfo: {
                weight: 'Weight',
                class: 'DispatchClass',
                partialFee: 'Balance'
            },
            RuntimeDispatchInfoV1: {
                weight: 'WeightV1',
                class: 'DispatchClass',
                partialFee: 'Balance'
            },
            RuntimeDispatchInfoV2: {
                weight: 'WeightV2',
                class: 'DispatchClass',
                partialFee: 'Balance'
            }
        }
    };

    const rpc = {
        call: {
            alias: ['state_callAt'],
            description: 'Perform a call to a builtin on the chain',
            params: [
                {
                    name: 'method',
                    type: 'Text'
                },
                {
                    name: 'data',
                    type: 'Bytes'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'Bytes'
        },
        getChildKeys: {
            description: 'Retrieves the keys with prefix of a specific child storage',
            params: [
                {
                    name: 'childStorageKey',
                    type: 'StorageKey'
                },
                {
                    name: 'childDefinition',
                    type: 'StorageKey'
                },
                {
                    name: 'childType',
                    type: 'u32'
                },
                {
                    name: 'key',
                    type: 'StorageKey'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'Vec<StorageKey>'
        },
        getChildReadProof: {
            description: 'Returns proof of storage for child key entries at a specific block state.',
            params: [
                {
                    name: 'childStorageKey',
                    type: 'PrefixedStorageKey'
                },
                {
                    name: 'keys',
                    type: 'Vec<StorageKey>'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'ReadProof'
        },
        getChildStorage: {
            description: 'Retrieves the child storage for a key',
            params: [
                {
                    name: 'childStorageKey',
                    type: 'StorageKey'
                },
                {
                    name: 'childDefinition',
                    type: 'StorageKey'
                },
                {
                    name: 'childType',
                    type: 'u32'
                },
                {
                    name: 'key',
                    type: 'StorageKey'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'StorageData'
        },
        getChildStorageHash: {
            description: 'Retrieves the child storage hash',
            params: [
                {
                    name: 'childStorageKey',
                    type: 'StorageKey'
                },
                {
                    name: 'childDefinition',
                    type: 'StorageKey'
                },
                {
                    name: 'childType',
                    type: 'u32'
                },
                {
                    name: 'key',
                    type: 'StorageKey'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'Hash'
        },
        getChildStorageSize: {
            description: 'Retrieves the child storage size',
            params: [
                {
                    name: 'childStorageKey',
                    type: 'StorageKey'
                },
                {
                    name: 'childDefinition',
                    type: 'StorageKey'
                },
                {
                    name: 'childType',
                    type: 'u32'
                },
                {
                    name: 'key',
                    type: 'StorageKey'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'u64'
        },
        getKeys: {
            deprecated: 'Use `api.rpc.state.getKeysPaged` to retrieve keys',
            description: 'Retrieves the keys with a certain prefix',
            params: [
                {
                    name: 'key',
                    type: 'StorageKey'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'Vec<StorageKey>'
        },
        getKeysPaged: {
            alias: ['state_getKeysPagedAt'],
            description: 'Returns the keys with prefix with pagination support.',
            params: [
                {
                    name: 'key',
                    type: 'StorageKey'
                },
                {
                    name: 'count',
                    type: 'u32'
                },
                {
                    isOptional: true,
                    name: 'startKey',
                    type: 'StorageKey'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'Vec<StorageKey>'
        },
        getMetadata: {
            description: 'Returns the runtime metadata',
            params: [
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'Metadata'
        },
        getPairs: {
            deprecated: 'Use `api.rpc.state.getKeysPaged` to retrieve keys',
            description: 'Returns the keys with prefix, leave empty to get all the keys (deprecated: Use getKeysPaged)',
            isUnsafe: true,
            params: [
                {
                    name: 'prefix',
                    type: 'StorageKey'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'Vec<KeyValue>'
        },
        getReadProof: {
            description: 'Returns proof of storage entries at a specific block state',
            params: [
                {
                    name: 'keys',
                    type: 'Vec<StorageKey>'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'ReadProof'
        },
        getRuntimeVersion: {
            alias: ['chain_getRuntimeVersion'],
            description: 'Get the runtime version',
            params: [
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'RuntimeVersion'
        },
        getStorage: {
            alias: ['state_getStorageAt'],
            description: 'Retrieves the storage for a key',
            params: [
                {
                    name: 'key',
                    type: 'StorageKey'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'StorageData'
        },
        getStorageHash: {
            alias: ['state_getStorageHashAt'],
            description: 'Retrieves the storage hash',
            params: [
                {
                    name: 'key',
                    type: 'StorageKey'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'Hash'
        },
        getStorageSize: {
            alias: ['state_getStorageSizeAt'],
            description: 'Retrieves the storage size',
            params: [
                {
                    name: 'key',
                    type: 'StorageKey'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'u64'
        },
        queryStorage: {
            description: 'Query historical storage entries (by key) starting from a start block',
            isUnsafe: true,
            params: [
                {
                    name: 'keys',
                    type: 'Vec<StorageKey>'
                },
                {
                    name: 'fromBlock',
                    type: 'Hash'
                },
                {
                    isOptional: true,
                    name: 'toBlock',
                    type: 'BlockHash'
                }
            ],
            type: 'Vec<StorageChangeSet>'
        },
        queryStorageAt: {
            description: 'Query storage entries (by key) starting at block hash given as the second parameter',
            params: [
                {
                    name: 'keys',
                    type: 'Vec<StorageKey>'
                },
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'Vec<StorageChangeSet>'
        },
        subscribeRuntimeVersion: {
            alias: ['chain_subscribeRuntimeVersion', 'chain_unsubscribeRuntimeVersion'],
            description: 'Retrieves the runtime version via subscription',
            params: [],
            pubsub: [
                'runtimeVersion',
                'subscribeRuntimeVersion',
                'unsubscribeRuntimeVersion'
            ],
            type: 'RuntimeVersion'
        },
        subscribeStorage: {
            description: 'Subscribes to storage changes for the provided keys',
            params: [
                {
                    isOptional: true,
                    name: 'keys',
                    type: 'Vec<StorageKey>'
                }
            ],
            pubsub: [
                'storage',
                'subscribeStorage',
                'unsubscribeStorage'
            ],
            type: 'StorageChangeSet'
        },
        traceBlock: {
            description: 'Provides a way to trace the re-execution of a single block',
            isUnsafe: true,
            params: [
                {
                    name: 'block',
                    type: 'Hash'
                },
                {
                    name: 'targets',
                    type: 'Option<Text>'
                },
                {
                    name: 'storageKeys',
                    type: 'Option<Text>'
                },
                {
                    name: 'methods',
                    type: 'Option<Text>'
                }
            ],
            type: 'TraceBlockResponse'
        },
        trieMigrationStatus: {
            description: 'Check current migration state',
            isUnsafe: true,
            params: [
                {
                    isHistoric: true,
                    isOptional: true,
                    name: 'at',
                    type: 'BlockHash'
                }
            ],
            type: 'MigrationStatusResult'
        }
    };

    const definitions$1 = {
        rpc,
        types: {
            ApiId: '[u8; 8]',
            BlockTrace: {
                blockHash: 'Text',
                parentHash: 'Text',
                tracingTargets: 'Text',
                storageKeys: 'Text',
                spans: 'Vec<BlockTraceSpan>',
                events: 'Vec<BlockTraceEvent>'
            },
            BlockTraceEvent: {
                target: 'Text',
                data: 'BlockTraceEventData',
                parentId: 'Option<u64>'
            },
            BlockTraceEventData: {
                stringValues: 'HashMap<Text, Text>'
            },
            BlockTraceSpan: {
                id: 'u64',
                parentId: 'Option<u64>',
                name: 'Text',
                target: 'Text',
                wasm: 'bool'
            },
            KeyValueOption: '(StorageKey, Option<StorageData>)',
            MigrationStatusResult: {
                topRemainingToMigrate: 'u64',
                childRemainingToMigrate: 'u64'
            },
            ReadProof: {
                at: 'Hash',
                proof: 'Vec<Bytes>'
            },
            RuntimeVersionApi: '(ApiId, u32)',
            RuntimeVersion: {
                specName: 'Text',
                implName: 'Text',
                authoringVersion: 'u32',
                specVersion: 'u32',
                implVersion: 'u32',
                apis: 'Vec<RuntimeVersionApi>',
                transactionVersion: 'u32',
                stateVersion: 'u8'
            },
            RuntimeVersionPre4: {
                specName: 'Text',
                implName: 'Text',
                authoringVersion: 'u32',
                specVersion: 'u32',
                implVersion: 'u32',
                apis: 'Vec<RuntimeVersionApi>',
                transactionVersion: 'u32'
            },
            RuntimeVersionPre3: {
                specName: 'Text',
                implName: 'Text',
                authoringVersion: 'u32',
                specVersion: 'u32',
                implVersion: 'u32',
                apis: 'Vec<RuntimeVersionApi>'
            },
            RuntimeVersionPartial: {
                specName: 'Text',
                specVersion: 'u32',
                apis: 'Vec<RuntimeVersionApi>'
            },
            SpecVersion: 'u32',
            StorageChangeSet: {
                block: 'Hash',
                changes: 'Vec<KeyValueOption>'
            },
            TraceBlockResponse: {
                _enum: {
                    TraceError: 'TraceError',
                    BlockTrace: 'BlockTrace'
                }
            },
            TraceError: {
                error: 'Text'
            }
        }
    };

    const definitions = /*#__PURE__*/Object.freeze({
        __proto__: null,
        assetConversion: definitions$14,
        assets: definitions$13,
        attestations: definitions$m,
        aura: definitions$12,
        author: definitions$6,
        authorship: definitions$11,
        babe: definitions$10,
        balances: definitions$$,
        beefy: definitions$_,
        benchmark: definitions$Z,
        blockbuilder: definitions$Y,
        bridges: definitions$l,
        chain: definitions$5,
        childstate: definitions$4,
        claims: definitions$k,
        collective: definitions$X,
        consensus: definitions$W,
        contracts: definitions$V,
        contractsAbi: definitions$c,
        crowdloan: definitions$j,
        cumulus: definitions$i,
        democracy: definitions$U,
        dev: definitions$T,
        discovery: definitions$S,
        elections: definitions$R,
        engine: definitions$Q,
        eth: definitions$b,
        evm: definitions$P,
        extrinsics: definitions$O,
        finality: definitions$h,
        fungibles: definitions$N,
        genericAsset: definitions$M,
        gilt: definitions$L,
        grandpa: definitions$K,
        identity: definitions$J,
        imOnline: definitions$I,
        lottery: definitions$H,
        metadata: definitions$17,
        mmr: definitions$G,
        nfts: definitions$F,
        nimbus: definitions$a,
        nompools: definitions$E,
        offchain: definitions$3,
        offences: definitions$D,
        ormlOracle: definitions$9,
        ormlTokens: definitions$8,
        parachains: definitions$g,
        payment: definitions$2,
        poll: definitions$f,
        pow: definitions$C,
        proxy: definitions$B,
        purchase: definitions$e,
        recovery: definitions$A,
        rpc: definitions$7,
        runtime: definitions$16,
        scaleInfo: definitions$15,
        scheduler: definitions$z,
        session: definitions$y,
        society: definitions$x,
        staking: definitions$w,
        state: definitions$1,
        support: definitions$v,
        syncstate: definitions$u,
        system: definitions$t,
        treasury: definitions$s,
        txpayment: definitions$r,
        txqueue: definitions$q,
        uniques: definitions$p,
        utility: definitions$o,
        vesting: definitions$n,
        xcm: definitions$d
    });

    const jsonrpc = {};
    Object.keys(definitions).forEach((s) => Object.entries(definitions[s].rpc || {}).forEach(([method, def]) => {
        const section = def.aliasSection || s;
        if (!jsonrpc[section]) {
            jsonrpc[section] = {};
        }
        jsonrpc[section][method] = util.objectSpread({}, def, {
            isSubscription: !!def.pubsub,
            jsonrpc: `${section}_${method}`,
            method,
            section
        });
    }));
    const jsonrpc$1 = jsonrpc;

    const l$2 = util.logger('PortableRegistry');
    const TYPE_UNWRAP = { toNumber: () => -1 };
    const PRIMITIVE_ALIAS = {
        Char: 'u32',
        Str: 'Text'
    };
    const PATHS_ALIAS = splitNamespace([
        'sp_core::crypto::AccountId32',
        'sp_runtime::generic::era::Era',
        'sp_runtime::multiaddress::MultiAddress',
        'fp_account::AccountId20',
        'account::AccountId20',
        'polkadot_runtime_common::claims::EthereumAddress',
        'frame_support::weights::weight_v2::Weight',
        'sp_weights::weight_v2::Weight',
        '*_democracy::vote::Vote',
        '*_conviction_voting::vote::Vote',
        '*_identity::types::Data',
        'sp_core::OpaqueMetadata',
        'sp_core::OpaquePeerId',
        'sp_core::offchain::OpaqueMultiaddr',
        'primitive_types::*',
        'sp_arithmetic::per_things::*',
        '*_runtime::RuntimeCall',
        '*_runtime::RuntimeEvent',
        'ink::env::types::*',
        'ink::primitives::types::*',
        'ink_env::types::*',
        'ink_primitives::types::*',
        'np_runtime::accountname::AccountName',
        'np_runtime::universaladdress::UniversalAddress'
    ]);
    const PATHS_SET = splitNamespace([
        'pallet_identity::types::BitFlags'
    ]);
    const BITVEC_NS_LSB = ['bitvec::order::Lsb0', 'BitOrderLsb0'];
    const BITVEC_NS_MSB = ['bitvec::order::Msb0', 'BitOrderMsb0'];
    const BITVEC_NS = [...BITVEC_NS_LSB, ...BITVEC_NS_MSB];
    const WRAPPERS = ['BoundedBTreeMap', 'BoundedBTreeSet', 'BoundedVec', 'Box', 'BTreeMap', 'BTreeSet', 'Cow', 'Option', 'Range', 'RangeInclusive', 'Result', 'WeakBoundedVec', 'WrapperKeepOpaque', 'WrapperOpaque'];
    const RESERVED = [
        'entries', 'keys', 'new', 'size',
        'hash', 'registry'
    ];
    const PATH_RM_INDEX_1 = ['generic', 'misc', 'pallet', 'traits', 'types'];
    function sanitizeDocs(docs) {
        const count = docs.length;
        const result = new Array(count);
        for (let i = 0; i < count; i++) {
            result[i] = docs[i].toString();
        }
        return result;
    }
    function splitNamespace(values) {
        const count = values.length;
        const result = new Array(count);
        for (let i = 0; i < count; i++) {
            result[i] = values[i].split('::');
        }
        return result;
    }
    function matchParts(first, second) {
        return first.length === second.length && first.every((a, index) => {
            const b = second[index].toString();
            if ((a === '*') || (a === b)) {
                return true;
            }
            if (a.includes('*') && a.includes('_') && b.includes('_')) {
                let suba = a.split('_');
                let subb = b.split('_');
                if (suba[0] === '*') {
                    const indexOf = subb.indexOf(suba[1]);
                    if (indexOf !== -1) {
                        suba = suba.slice(1);
                        subb = subb.slice(indexOf);
                    }
                }
                if ((suba.length === 2) && (suba[1] === '*') && (suba[0] === subb[0])) {
                    return true;
                }
                return matchParts(suba, subb);
            }
            return false;
        });
    }
    function getAliasPath({ def, path }) {
        if (['frame_support::weights::weight_v2::Weight', 'sp_weights::weight_v2::Weight'].includes(path.join('::'))) {
            return !def.isComposite || def.asComposite.fields.length === 1
                ? 'WeightV1'
                : null;
        }
        return path.length && PATHS_ALIAS.some((a) => matchParts(a, path))
            ? path[path.length - 1].toString()
            : null;
    }
    function extractNameFlat(portable, lookupIndex, params, path, isInternal = false) {
        const count = path.length;
        if (count === 0 || WRAPPERS.includes(path[count - 1].toString())) {
            return null;
        }
        const camels = new Array(count);
        const lowers = new Array(count);
        for (let i = 0; i < count; i++) {
            const c = util.stringPascalCase(isInternal
                ? path[i].replace('pallet_', '')
                : path[i]);
            const l = c.toLowerCase();
            camels[i] = c;
            lowers[i] = l;
        }
        let name = '';
        for (let i = 0; i < count; i++) {
            const l = lowers[i];
            if (i !== 1 || !PATH_RM_INDEX_1.includes(l)) {
                if (l !== lowers[i + 1]) {
                    name += camels[i];
                }
            }
        }
        if (camels[1] === 'RawOrigin' && count === 2 && params.length === 2 && params[1].type.isSome) {
            const instanceType = portable[params[1].type.unwrap().toNumber()];
            if (instanceType.type.path.length === 2) {
                name = `${name}${instanceType.type.path[1].toString()}`;
            }
        }
        return { lookupIndex, name, params };
    }
    function extractName(portable, lookupIndex, { type: { params, path } }) {
        return extractNameFlat(portable, lookupIndex, params, path);
    }
    function nextDupeMatches(name, startAt, names) {
        const result = [names[startAt]];
        for (let i = startAt + 1, count = names.length; i < count; i++) {
            const v = names[i];
            if (v.name === name) {
                result.push(v);
            }
        }
        return result;
    }
    function rewriteDupes(input, rewrite) {
        const count = input.length;
        for (let i = 0; i < count; i++) {
            const a = input[i];
            for (let j = i + 1; j < count; j++) {
                const b = input[j];
                if (a.lookupIndex !== b.lookupIndex && a.name === b.name) {
                    return false;
                }
            }
        }
        for (let i = 0; i < count; i++) {
            const p = input[i];
            rewrite[p.lookupIndex] = p.name;
        }
        return true;
    }
    function removeDupeNames(lookup, portable, names) {
        const rewrite = {};
        return names
            .map((original, startAt) => {
            const { lookupIndex, name, params } = original;
            if (!name) {
                return null;
            }
            else if (rewrite[lookupIndex]) {
                return original;
            }
            const allSame = nextDupeMatches(name, startAt, names);
            if (allSame.length === 1) {
                return original;
            }
            const anyDiff = allSame.some((o) => params.length !== o.params.length ||
                params.some((p, index) => !p.name.eq(o.params[index].name) ||
                    p.type.unwrapOr(TYPE_UNWRAP).toNumber() !== o.params[index].type.unwrapOr(TYPE_UNWRAP).toNumber()));
            if (!anyDiff) {
                return original;
            }
            const paramIdx = params.findIndex(({ type }, index) => allSame.every(({ params }, aIndex) => params[index].type.isSome && (aIndex === 0 ||
                !params[index].type.eq(type))));
            if (paramIdx === -1) {
                return original;
            }
            const sameCount = allSame.length;
            const adjusted = new Array(sameCount);
            for (let i = 0; i < sameCount; i++) {
                const { lookupIndex, name, params } = allSame[i];
                const { def, path } = lookup.getSiType(params[paramIdx].type.unwrap());
                if (!def.isPrimitive && !path.length) {
                    return null;
                }
                adjusted[i] = {
                    lookupIndex,
                    name: def.isPrimitive
                        ? `${name}${def.asPrimitive.toString()}`
                        : `${name}${path[path.length - 1].toString()}`
                };
            }
            if (rewriteDupes(adjusted, rewrite)) {
                return original;
            }
            for (let i = 0; i < sameCount; i++) {
                const { lookupIndex, name, params } = allSame[i];
                const { def, path } = lookup.getSiType(params[paramIdx].type.unwrap());
                const flat = extractNameFlat(portable, lookupIndex, params, path, true);
                if (def.isPrimitive || !flat) {
                    return null;
                }
                adjusted[i] = {
                    lookupIndex,
                    name: `${name}${flat.name}`
                };
            }
            if (rewriteDupes(adjusted, rewrite)) {
                return original;
            }
            return null;
        })
            .filter((n) => !!n)
            .map(({ lookupIndex, name, params }) => ({
            lookupIndex,
            name: rewrite[lookupIndex] || name,
            params
        }));
    }
    function registerTypes(lookup, lookups, names, params) {
        lookup.registry.register(lookups);
        if (params.SpRuntimeUncheckedExtrinsic) {
            const [addrParam, , sigParam] = params.SpRuntimeUncheckedExtrinsic;
            const siAddress = lookup.getSiType(addrParam.type.unwrap());
            const siSignature = lookup.getSiType(sigParam.type.unwrap());
            const nsSignature = siSignature.path.join('::');
            let nsAccountId = siAddress.path.join('::');
            const isMultiAddress = nsAccountId === 'sp_runtime::multiaddress::MultiAddress';
            if (isMultiAddress) {
                const [idParam] = siAddress.params;
                nsAccountId = lookup.getSiType(idParam.type.unwrap()).path.join('::');
            }
            lookup.registry.register({
                AccountId: nsAccountId.endsWith('::AccountId20') || nsAccountId.endsWith('::H160')
                    ? 'AccountId20'
                    : 'AccountId32',
                Address: isMultiAddress
                    ? 'MultiAddress'
                    : 'AccountId',
                ExtrinsicSignature: ['sp_runtime::MultiSignature'].includes(nsSignature)
                    ? 'MultiSignature'
                    : names[sigParam.type.unwrap().toNumber()] || 'MultiSignature'
            });
        }
    }
    function extractAliases(params, isContract) {
        const hasParams = Object.keys(params).some((k) => !k.startsWith('Pallet'));
        const alias = {};
        if (params.SpRuntimeUncheckedExtrinsic) {
            const [, { type }] = params.SpRuntimeUncheckedExtrinsic;
            alias[type.unwrap().toNumber()] = 'Call';
        }
        else if (hasParams && !isContract) {
            l$2.warn('Unable to determine runtime Call type, cannot inspect sp_runtime::generic::unchecked_extrinsic::UncheckedExtrinsic');
        }
        if (params.FrameSystemEventRecord) {
            const [{ type }] = params.FrameSystemEventRecord;
            alias[type.unwrap().toNumber()] = 'Event';
        }
        else if (hasParams && !isContract) {
            l$2.warn('Unable to determine runtime Event type, cannot inspect frame_system::EventRecord');
        }
        return alias;
    }
    function extractTypeInfo(lookup, portable) {
        const nameInfo = [];
        const types = {};
        for (let i = 0, count = portable.length; i < count; i++) {
            const type = portable[i];
            const lookupIndex = type.id.toNumber();
            const extracted = extractName(portable, lookupIndex, portable[i]);
            if (extracted) {
                nameInfo.push(extracted);
            }
            types[lookupIndex] = type;
        }
        const lookups = {};
        const names = {};
        const params = {};
        const dedup = removeDupeNames(lookup, portable, nameInfo);
        for (let i = 0, count = dedup.length; i < count; i++) {
            const { lookupIndex, name, params: p } = dedup[i];
            names[lookupIndex] = name;
            lookups[name] = lookup.registry.createLookupType(lookupIndex);
            params[name] = p;
        }
        return { lookups, names, params, types };
    }
    class PortableRegistry extends Struct {
        __internal__alias;
        __internal__lookups;
        __internal__names;
        __internal__params;
        __internal__typeDefs = {};
        __internal__types;
        constructor(registry, value, isContract) {
            super(registry, {
                types: 'Vec<PortableType>'
            }, value);
            const { lookups, names, params, types } = extractTypeInfo(this, this.types);
            this.__internal__alias = extractAliases(params, isContract);
            this.__internal__lookups = lookups;
            this.__internal__names = names;
            this.__internal__params = params;
            this.__internal__types = types;
        }
        get names() {
            return Object.values(this.__internal__names).sort();
        }
        get paramTypes() {
            return this.__internal__params;
        }
        get types() {
            return this.getT('types');
        }
        register() {
            registerTypes(this, this.__internal__lookups, this.__internal__names, this.__internal__params);
        }
        getName(lookupId) {
            return this.__internal__names[this.__internal__getLookupId(lookupId)];
        }
        getSiType(lookupId) {
            const found = (this.__internal__types || this.types)[this.__internal__getLookupId(lookupId)];
            if (!found) {
                throw new Error(`PortableRegistry: Unable to find type with lookupId ${lookupId.toString()}`);
            }
            return found.type;
        }
        getTypeDef(lookupId) {
            const lookupIndex = this.__internal__getLookupId(lookupId);
            if (!this.__internal__typeDefs[lookupIndex]) {
                const lookupName = this.__internal__names[lookupIndex];
                const empty = {
                    info: exports.TypeDefInfo.DoNotConstruct,
                    lookupIndex,
                    lookupName,
                    type: this.registry.createLookupType(lookupIndex)
                };
                if (lookupName) {
                    this.__internal__typeDefs[lookupIndex] = empty;
                }
                const extracted = this.__internal__extract(this.getSiType(lookupId), lookupIndex);
                if (!lookupName) {
                    this.__internal__typeDefs[lookupIndex] = empty;
                }
                Object.keys(extracted).forEach((k) => {
                    if (k !== 'lookupName' || extracted[k]) {
                        this.__internal__typeDefs[lookupIndex][k] = extracted[k];
                    }
                });
                if (extracted.info === exports.TypeDefInfo.Plain) {
                    this.__internal__typeDefs[lookupIndex].lookupNameRoot = this.__internal__typeDefs[lookupIndex].lookupName;
                    delete this.__internal__typeDefs[lookupIndex].lookupName;
                }
            }
            return this.__internal__typeDefs[lookupIndex];
        }
        sanitizeField(name) {
            let nameField = null;
            let nameOrig = null;
            if (name.isSome) {
                nameField = util.stringCamelCase(name.unwrap());
                if (nameField.includes('#')) {
                    nameOrig = nameField;
                    nameField = nameOrig.replace(/#/g, '_');
                }
                else if (RESERVED.includes(nameField)) {
                    nameOrig = nameField;
                    nameField = `${nameField}_`;
                }
            }
            return [nameField, nameOrig];
        }
        __internal__createSiDef(lookupId) {
            const typeDef = this.getTypeDef(lookupId);
            const lookupIndex = lookupId.toNumber();
            return [exports.TypeDefInfo.DoNotConstruct, exports.TypeDefInfo.Enum, exports.TypeDefInfo.Struct].includes(typeDef.info) && typeDef.lookupName
                ? {
                    docs: typeDef.docs,
                    info: exports.TypeDefInfo.Si,
                    lookupIndex,
                    lookupName: this.__internal__names[lookupIndex],
                    type: this.registry.createLookupType(lookupId)
                }
                : typeDef;
        }
        __internal__getLookupId(lookupId) {
            if (util.isString(lookupId)) {
                if (!this.registry.isLookupType(lookupId)) {
                    throw new Error(`PortableRegistry: Expected a lookup string type, found ${lookupId}`);
                }
                return parseInt(lookupId.replace('Lookup', ''), 10);
            }
            else if (util.isNumber(lookupId)) {
                return lookupId;
            }
            return lookupId.toNumber();
        }
        __internal__extract(type, lookupIndex) {
            const namespace = type.path.join('::');
            let typeDef;
            const aliasType = this.__internal__alias[lookupIndex] || getAliasPath(type);
            try {
                if (aliasType) {
                    typeDef = this.__internal__extractAliasPath(lookupIndex, aliasType);
                }
                else {
                    switch (type.def.type) {
                        case 'Array':
                            typeDef = this.__internal__extractArray(lookupIndex, type.def.asArray);
                            break;
                        case 'BitSequence':
                            typeDef = this.__internal__extractBitSequence(lookupIndex, type.def.asBitSequence);
                            break;
                        case 'Compact':
                            typeDef = this.__internal__extractCompact(lookupIndex, type.def.asCompact);
                            break;
                        case 'Composite':
                            typeDef = this.__internal__extractComposite(lookupIndex, type, type.def.asComposite);
                            break;
                        case 'HistoricMetaCompat':
                            typeDef = this.__internal__extractHistoric(lookupIndex, type.def.asHistoricMetaCompat);
                            break;
                        case 'Primitive':
                            typeDef = this.__internal__extractPrimitive(lookupIndex, type);
                            break;
                        case 'Sequence':
                            typeDef = this.__internal__extractSequence(lookupIndex, type.def.asSequence);
                            break;
                        case 'Tuple':
                            typeDef = this.__internal__extractTuple(lookupIndex, type.def.asTuple);
                            break;
                        case 'Variant':
                            typeDef = this.__internal__extractVariant(lookupIndex, type, type.def.asVariant);
                            break;
                        default: util.assertUnreachable(type.def.type);
                    }
                }
            }
            catch (error) {
                throw new Error(`PortableRegistry: ${lookupIndex}${namespace ? ` (${namespace})` : ''}: Error extracting ${util.stringify(type)}: ${error.message}`);
            }
            return util.objectSpread({
                docs: sanitizeDocs(type.docs),
                namespace
            }, typeDef);
        }
        __internal__extractArray(_, { len, type }) {
            const length = len.toNumber();
            if (length > 2048) {
                throw new Error('Only support for [Type; <length>], where length <= 2048');
            }
            return withTypeString(this.registry, {
                info: exports.TypeDefInfo.VecFixed,
                length,
                sub: this.__internal__createSiDef(type)
            });
        }
        __internal__extractBitSequence(_, { bitOrderType, bitStoreType }) {
            const a = this.__internal__createSiDef(bitOrderType);
            const b = this.__internal__createSiDef(bitStoreType);
            const [bitOrder, bitStore] = BITVEC_NS.includes(a.namespace || '')
                ? [a, b]
                : [b, a];
            if (!bitOrder.namespace || !BITVEC_NS.includes(bitOrder.namespace)) {
                throw new Error(`Unexpected bitOrder found as ${bitOrder.namespace || '<unknown>'}`);
            }
            else if (bitStore.info !== exports.TypeDefInfo.Plain || bitStore.type !== 'u8') {
                throw new Error(`Only u8 bitStore is currently supported, found ${bitStore.type}`);
            }
            BITVEC_NS_LSB.includes(bitOrder.namespace);
            return {
                info: exports.TypeDefInfo.Plain,
                type: 'BitVec'
            };
        }
        __internal__extractCompact(_, { type }) {
            return withTypeString(this.registry, {
                info: exports.TypeDefInfo.Compact,
                sub: this.__internal__createSiDef(type)
            });
        }
        __internal__extractComposite(lookupIndex, { params, path }, { fields }) {
            if (path.length) {
                const pathFirst = path[0].toString();
                const pathLast = path[path.length - 1].toString();
                if (path.length === 1 && pathFirst === 'BTreeMap') {
                    if (params.length !== 2) {
                        throw new Error(`BTreeMap requires 2 parameters, found ${params.length}`);
                    }
                    return withTypeString(this.registry, {
                        info: exports.TypeDefInfo.BTreeMap,
                        sub: params.map(({ type }) => this.__internal__createSiDef(type.unwrap()))
                    });
                }
                else if (path.length === 1 && pathFirst === 'BTreeSet') {
                    if (params.length !== 1) {
                        throw new Error(`BTreeSet requires 1 parameter, found ${params.length}`);
                    }
                    return withTypeString(this.registry, {
                        info: exports.TypeDefInfo.BTreeSet,
                        sub: this.__internal__createSiDef(params[0].type.unwrap())
                    });
                }
                else if (['Range', 'RangeInclusive'].includes(pathFirst)) {
                    if (params.length !== 1) {
                        throw new Error(`Range requires 1 parameter, found ${params.length}`);
                    }
                    return withTypeString(this.registry, {
                        info: pathFirst === 'Range'
                            ? exports.TypeDefInfo.Range
                            : exports.TypeDefInfo.RangeInclusive,
                        sub: this.__internal__createSiDef(params[0].type.unwrap()),
                        type: pathFirst
                    });
                }
                else if (['WrapperKeepOpaque', 'WrapperOpaque'].includes(pathLast)) {
                    if (params.length !== 1) {
                        throw new Error(`WrapperOpaque requires 1 parameter, found ${params.length}`);
                    }
                    return withTypeString(this.registry, {
                        info: pathLast === 'WrapperKeepOpaque'
                            ? exports.TypeDefInfo.WrapperKeepOpaque
                            : exports.TypeDefInfo.WrapperOpaque,
                        sub: this.__internal__createSiDef(params[0].type.unwrap()),
                        type: pathLast
                    });
                }
            }
            return PATHS_SET.some((p) => matchParts(p, path))
                ? this.__internal__extractCompositeSet(lookupIndex, params, fields)
                : this.__internal__extractFields(lookupIndex, fields);
        }
        __internal__extractCompositeSet(_, params, fields) {
            if (params.length !== 1 || fields.length !== 1) {
                throw new Error('Set handling expects param/field as single entries');
            }
            return withTypeString(this.registry, {
                info: exports.TypeDefInfo.Set,
                length: this.registry.createTypeUnsafe(this.registry.createLookupType(fields[0].type), []).bitLength(),
                sub: this.getSiType(params[0].type.unwrap()).def.asVariant.variants.map(({ index, name }) => ({
                    index: index.toNumber(),
                    info: exports.TypeDefInfo.Plain,
                    name: name.toString(),
                    type: 'Null'
                }))
            });
        }
        __internal__extractFields(lookupIndex, fields) {
            let isStruct = true;
            let isTuple = true;
            const count = fields.length;
            for (let f = 0; f < count; f++) {
                const { name } = fields[f];
                isStruct = isStruct && name.isSome;
                isTuple = isTuple && name.isNone;
            }
            if (!isTuple && !isStruct) {
                throw new Error('Invalid fields type detected, expected either Tuple (all unnamed) or Struct (all named)');
            }
            if (count === 0) {
                return {
                    info: exports.TypeDefInfo.Null,
                    type: 'Null'
                };
            }
            else if (isTuple && count === 1) {
                const typeDef = this.__internal__createSiDef(fields[0].type);
                return util.objectSpread({}, typeDef, lookupIndex === -1
                    ? null
                    : {
                        lookupIndex,
                        lookupName: this.__internal__names[lookupIndex],
                        lookupNameRoot: typeDef.lookupName
                    }, fields[0].typeName.isSome
                    ? { typeName: sanitize(fields[0].typeName.unwrap()) }
                    : null);
            }
            const [sub, alias] = this.__internal__extractFieldsAlias(fields);
            return withTypeString(this.registry, util.objectSpread({
                info: isTuple
                    ? exports.TypeDefInfo.Tuple
                    : exports.TypeDefInfo.Struct,
                sub
            }, alias.size
                ? { alias }
                : null, lookupIndex === -1
                ? null
                : {
                    lookupIndex,
                    lookupName: this.__internal__names[lookupIndex]
                }));
        }
        __internal__extractFieldsAlias(fields) {
            const alias = new Map();
            const count = fields.length;
            const sub = new Array(count);
            for (let i = 0; i < count; i++) {
                const { docs, name, type, typeName } = fields[i];
                const typeDef = this.__internal__createSiDef(type);
                if (name.isNone) {
                    sub[i] = typeDef;
                }
                else {
                    const [nameField, nameOrig] = this.sanitizeField(name);
                    if (nameField && nameOrig) {
                        alias.set(nameField, nameOrig);
                    }
                    sub[i] = util.objectSpread({
                        docs: sanitizeDocs(docs),
                        name: nameField
                    }, typeDef, typeName.isSome
                        ? { typeName: sanitize(typeName.unwrap()) }
                        : null);
                }
            }
            return [sub, alias];
        }
        __internal__extractHistoric(_, type) {
            return util.objectSpread({
                displayName: type.toString(),
                isFromSi: true
            }, getTypeDef(type));
        }
        __internal__extractPrimitive(_, type) {
            const typeStr = type.def.asPrimitive.type.toString();
            return {
                info: exports.TypeDefInfo.Plain,
                type: PRIMITIVE_ALIAS[typeStr] || typeStr.toLowerCase()
            };
        }
        __internal__extractAliasPath(_, type) {
            return {
                info: exports.TypeDefInfo.Plain,
                type
            };
        }
        __internal__extractSequence(lookupIndex, { type }) {
            const sub = this.__internal__createSiDef(type);
            if (sub.type === 'u8') {
                return {
                    info: exports.TypeDefInfo.Plain,
                    type: 'Bytes'
                };
            }
            return withTypeString(this.registry, {
                info: exports.TypeDefInfo.Vec,
                lookupIndex,
                lookupName: this.__internal__names[lookupIndex],
                sub
            });
        }
        __internal__extractTuple(lookupIndex, ids) {
            if (ids.length === 0) {
                return {
                    info: exports.TypeDefInfo.Null,
                    type: 'Null'
                };
            }
            else if (ids.length === 1) {
                return this.getTypeDef(ids[0]);
            }
            const sub = ids.map((t) => this.__internal__createSiDef(t));
            return withTypeString(this.registry, {
                info: exports.TypeDefInfo.Tuple,
                lookupIndex,
                lookupName: this.__internal__names[lookupIndex],
                sub
            });
        }
        __internal__extractVariant(lookupIndex, { params, path }, { variants }) {
            if (path.length) {
                const specialVariant = path[0].toString();
                if (specialVariant === 'Option') {
                    if (params.length !== 1) {
                        throw new Error(`Option requires 1 parameter, found ${params.length}`);
                    }
                    return withTypeString(this.registry, {
                        info: exports.TypeDefInfo.Option,
                        sub: this.__internal__createSiDef(params[0].type.unwrap())
                    });
                }
                else if (specialVariant === 'Result') {
                    if (params.length !== 2) {
                        throw new Error(`Result requires 2 parameters, found ${params.length}`);
                    }
                    return withTypeString(this.registry, {
                        info: exports.TypeDefInfo.Result,
                        sub: params.map(({ type }, index) => util.objectSpread({
                            name: ['Ok', 'Error'][index]
                        }, this.__internal__createSiDef(type.unwrap())))
                    });
                }
            }
            if (variants.length === 0) {
                return {
                    info: exports.TypeDefInfo.Null,
                    type: 'Null'
                };
            }
            return this.__internal__extractVariantEnum(lookupIndex, variants);
        }
        __internal__extractVariantEnum(lookupIndex, variants) {
            const sub = [];
            variants
                .slice()
                .sort((a, b) => a.index.cmp(b.index))
                .forEach(({ fields, index: bnIndex, name }) => {
                const index = bnIndex.toNumber();
                while (sub.length !== index) {
                    sub.push({
                        index: sub.length,
                        info: exports.TypeDefInfo.Null,
                        name: `__Unused${sub.length}`,
                        type: 'Null'
                    });
                }
                sub.push(util.objectSpread(this.__internal__extractFields(-1, fields), {
                    index,
                    name: name.toString()
                }));
            });
            return withTypeString(this.registry, {
                info: exports.TypeDefInfo.Enum,
                lookupIndex,
                lookupName: this.__internal__names[lookupIndex],
                sub
            });
        }
    }

    function convertType(key) {
        return (registry, { type }) => registry.createType('Si1TypeDef', {
            [key]: {
                type: type.toNumber()
            }
        });
    }
    function convertArray(registry, { len, type }) {
        return registry.createType('Si1TypeDef', {
            Array: {
                len,
                type: type.toNumber()
            }
        });
    }
    function convertBitSequence(registry, { bitOrderType, bitStoreType }) {
        return registry.createType('Si1TypeDef', {
            BitSequence: {
                bitOrderType: bitOrderType.toNumber(),
                bitStoreType: bitStoreType.toNumber()
            }
        });
    }
    const convertCompact = convertType('Compact');
    function convertComposite(registry, { fields }) {
        return registry.createType('Si1TypeDef', {
            Composite: {
                fields: convertFields(registry, fields)
            }
        });
    }
    function convertFields(registry, fields) {
        return fields.map(({ docs, name, type, typeName }) => registry.createType('Si1Field', {
            docs,
            name,
            type: type.toNumber(),
            typeName
        }));
    }
    function convertPhantom(registry, path) {
        console.warn(`Converting phantom type ${path.map((p) => p.toString()).join('::')} to empty tuple`);
        return registry.createType('Si1TypeDef', {
            Tuple: []
        });
    }
    function convertPrimitive(registry, prim) {
        return registry.createType('Si1TypeDef', {
            Primitive: prim.toString()
        });
    }
    const convertSequence = convertType('Sequence');
    function convertTuple(registry, types) {
        return registry.createType('Si1TypeDef', {
            Tuple: types.map((t) => t.toNumber())
        });
    }
    function convertVariant(registry, { variants }) {
        return registry.createType('Si1TypeDef', {
            Variant: {
                variants: variants.map(({ discriminant, docs, fields, name }, index) => registry.createType('Si1Variant', {
                    docs,
                    fields: convertFields(registry, fields),
                    index: discriminant.isSome
                        ? discriminant.unwrap().toNumber()
                        : index,
                    name
                }))
            }
        });
    }
    function convertDef(registry, { def, path }) {
        let result;
        switch (def.type) {
            case 'Array':
                result = convertArray(registry, def.asArray);
                break;
            case 'BitSequence':
                result = convertBitSequence(registry, def.asBitSequence);
                break;
            case 'Compact':
                result = convertCompact(registry, def.asCompact);
                break;
            case 'Composite':
                result = convertComposite(registry, def.asComposite);
                break;
            case 'Phantom':
                result = convertPhantom(registry, path);
                break;
            case 'Primitive':
                result = convertPrimitive(registry, def.asPrimitive);
                break;
            case 'Sequence':
                result = convertSequence(registry, def.asSequence);
                break;
            case 'Tuple':
                result = convertTuple(registry, def.asTuple);
                break;
            case 'Variant':
                result = convertVariant(registry, def.asVariant);
                break;
            default: util.assertUnreachable(def.type);
        }
        return result;
    }
    function toV1(registry, types) {
        return types.map((t, index) => registry.createType('PortableType', {
            id: index + 1,
            type: {
                def: convertDef(registry, t),
                docs: [],
                params: t.params.map((p) => registry.createType('Si1TypeParameter', {
                    type: p.toNumber()
                })),
                path: t.path.map((p) => p.toString())
            }
        }));
    }

    const packageInfo = { name: '@polkadot/types', path: (({ url: (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-types.js', document.baseURI).href)) }) && (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-types.js', document.baseURI).href))) ? new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-types.js', document.baseURI).href))).pathname.substring(0, new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-types.js', document.baseURI).href))).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '10.11.1' };

    function flattenUniq(list, result = []) {
        for (let i = 0, count = list.length; i < count; i++) {
            const entry = list[i];
            if (Array.isArray(entry)) {
                flattenUniq(entry, result);
            }
            else {
                result.push(entry);
            }
        }
        return [...new Set(result)];
    }

    function getSiName(lookup, type) {
        const typeDef = lookup.getTypeDef(type);
        return typeDef.lookupName || typeDef.type;
    }

    function extractSubSingle(_, { sub }) {
        const { lookupName, type } = sub;
        return extractTypes$1([lookupName || type]);
    }
    function extractSubArray(_, { sub }) {
        return extractTypes$1(sub.map(({ lookupName, type }) => lookupName || type));
    }
    function unhandled(type, { info }) {
        throw new Error(`Unhandled: Unable to create and validate type from ${type} (info=${exports.TypeDefInfo[info]})`);
    }
    const mapping = {
        [exports.TypeDefInfo.BTreeMap]: extractSubArray,
        [exports.TypeDefInfo.BTreeSet]: extractSubSingle,
        [exports.TypeDefInfo.Compact]: extractSubSingle,
        [exports.TypeDefInfo.DoNotConstruct]: unhandled,
        [exports.TypeDefInfo.Enum]: extractSubArray,
        [exports.TypeDefInfo.HashMap]: extractSubArray,
        [exports.TypeDefInfo.Int]: unhandled,
        [exports.TypeDefInfo.Linkage]: extractSubSingle,
        [exports.TypeDefInfo.Null]: unhandled,
        [exports.TypeDefInfo.Option]: extractSubSingle,
        [exports.TypeDefInfo.Plain]: (_, typeDef) => typeDef.lookupName || typeDef.type,
        [exports.TypeDefInfo.Range]: extractSubSingle,
        [exports.TypeDefInfo.RangeInclusive]: extractSubSingle,
        [exports.TypeDefInfo.Result]: extractSubArray,
        [exports.TypeDefInfo.Set]: extractSubArray,
        [exports.TypeDefInfo.Si]: unhandled,
        [exports.TypeDefInfo.Struct]: extractSubArray,
        [exports.TypeDefInfo.Tuple]: extractSubArray,
        [exports.TypeDefInfo.UInt]: unhandled,
        [exports.TypeDefInfo.Vec]: extractSubSingle,
        [exports.TypeDefInfo.VecFixed]: extractSubSingle,
        [exports.TypeDefInfo.WrapperKeepOpaque]: extractSubSingle,
        [exports.TypeDefInfo.WrapperOpaque]: extractSubSingle
    };
    function extractTypes$1(types) {
        const count = types.length;
        const result = new Array(count);
        for (let i = 0; i < count; i++) {
            const type = types[i];
            const typeDef = getTypeDef(type);
            result[i] = mapping[typeDef.info](type, typeDef);
        }
        return result;
    }

    const l$1 = util.logger('metadata');
    function validateTypes(registry, throwError, types) {
        const missing = flattenUniq(extractTypes$1(types))
            .filter((type) => !registry.hasType(type) &&
            !registry.isLookupType(type))
            .sort();
        if (missing.length !== 0) {
            const message = `Unknown types found, no types for ${missing.join(', ')}`;
            if (throwError) {
                throw new Error(message);
            }
            else {
                l$1.warn(message);
            }
        }
        return types;
    }

    function extractTypes(lookup, types) {
        return types.map(({ type }) => lookup.getTypeDef(type).type);
    }
    function extractFieldTypes(lookup, type) {
        return lookup.getSiType(type).def.asVariant.variants.map(({ fields }) => extractTypes(lookup, fields));
    }
    function getPalletNames({ lookup, pallets }) {
        return pallets.reduce((all, { calls, constants, events, storage }) => {
            all.push([extractTypes(lookup, constants)]);
            if (calls.isSome) {
                all.push(extractFieldTypes(lookup, calls.unwrap().type));
            }
            if (events.isSome) {
                all.push(extractFieldTypes(lookup, events.unwrap().type));
            }
            if (storage.isSome) {
                all.push(storage.unwrap().items.map(({ type }) => {
                    if (type.isPlain) {
                        return [lookup.getTypeDef(type.asPlain).type];
                    }
                    const { hashers, key, value } = type.asMap;
                    return hashers.length === 1
                        ? [
                            lookup.getTypeDef(value).type,
                            lookup.getTypeDef(key).type
                        ]
                        : [
                            lookup.getTypeDef(value).type,
                            ...lookup.getSiType(key).def.asTuple.map((t) => lookup.getTypeDef(t).type)
                        ];
                }));
            }
            return all;
        }, []);
    }
    function getUniqTypes(registry, meta, throwError) {
        return validateTypes(registry, throwError, flattenUniq(getPalletNames(meta)));
    }

    function trimDocs(docs) {
        const strings = docs.map((d) => d.toString().trim());
        const firstEmpty = strings.findIndex((d) => !d.length);
        return firstEmpty === -1
            ? strings
            : strings.slice(0, firstEmpty);
    }
    function toCallsOnly(registry, { extrinsic, lookup, pallets }) {
        return registry.createTypeUnsafe('MetadataLatest', [{
                extrinsic,
                lookup: {
                    types: lookup.types.map(({ id, type }) => registry.createTypeUnsafe('PortableType', [{
                            id,
                            type: util.objectSpread({}, type, { docs: trimDocs(type.docs) })
                        }]))
                },
                pallets: pallets.map(({ calls, index, name }) => ({
                    calls: registry.createTypeUnsafe('Option<PalletCallMetadataLatest>', [calls.unwrapOr(null)]),
                    index,
                    name
                }))
            }]).toJSON();
    }

    function unwrapStorageSi(type) {
        return type.isPlain
            ? type.asPlain
            : type.asMap.value;
    }
    function unwrapStorageType(registry, type, isOptional) {
        const outputType = getSiName(registry.lookup, unwrapStorageSi(type));
        return isOptional
            ? `Option<${outputType}>`
            : outputType;
    }

    function createClass(registry, type) {
        return createClassUnsafe(registry, type);
    }

    function createType(registry, type, ...params) {
        return createTypeUnsafe(registry, type, params);
    }

    function lazyVariants(lookup, { type }, getName, creator) {
        const result = {};
        const variants = lookup.getSiType(type).def.asVariant.variants;
        for (let i = 0, count = variants.length; i < count; i++) {
            util.lazyMethod(result, variants[i], creator, getName, i);
        }
        return result;
    }

    const emptyCheck = {
        extrinsic: {},
        payload: {}
    };

    const polkadot = {
        LimitParathreadCommits: emptyCheck,
        OnlyStakingAndClaims: emptyCheck,
        PrevalidateAttests: emptyCheck,
        RestrictFunctionality: emptyCheck,
        TransactionCallFilter: emptyCheck,
        ValidateDoubleVoteReports: emptyCheck
    };

    const shell = {
        DisallowSigned: emptyCheck
    };

    const statemint = {
        ChargeAssetTxPayment: {
            extrinsic: {
                tip: 'Compact<Balance>',
                assetId: 'TAssetConversion'
            },
            payload: {}
        }
    };

    const CheckMortality = {
        extrinsic: {
            era: 'ExtrinsicEra'
        },
        payload: {
            blockHash: 'Hash'
        }
    };
    const ChargeTransactionPayment = {
        extrinsic: {
            tip: 'Compact<Balance>'
        },
        payload: {}
    };
    const substrate$1 = {
        ChargeTransactionPayment,
        CheckBlockGasLimit: emptyCheck,
        CheckEra: CheckMortality,
        CheckGenesis: {
            extrinsic: {},
            payload: {
                genesisHash: 'Hash'
            }
        },
        CheckMortality,
        CheckNonZeroSender: emptyCheck,
        CheckNonce: {
            extrinsic: {
                nonce: 'Compact<Index>'
            },
            payload: {}
        },
        CheckSpecVersion: {
            extrinsic: {},
            payload: {
                specVersion: 'u32'
            }
        },
        CheckTxVersion: {
            extrinsic: {},
            payload: {
                transactionVersion: 'u32'
            }
        },
        CheckVersion: {
            extrinsic: {},
            payload: {
                specVersion: 'u32'
            }
        },
        CheckWeight: emptyCheck,
        LockStakingStatus: emptyCheck,
        SkipCheckIfFeeless: ChargeTransactionPayment,
        ValidateEquivocationReport: emptyCheck
    };

    const allExtensions = util.objectSpread({}, substrate$1, polkadot, shell, statemint);
    const fallbackExtensions = [
        'CheckVersion',
        'CheckGenesis',
        'CheckEra',
        'CheckNonce',
        'CheckWeight',
        'ChargeTransactionPayment',
        'CheckBlockGasLimit'
    ];
    function findUnknownExtensions(extensions, userExtensions = {}) {
        const names = [...Object.keys(allExtensions), ...Object.keys(userExtensions)];
        return extensions.filter((k) => !names.includes(k));
    }
    function expandExtensionTypes(extensions, type, userExtensions = {}) {
        return extensions
            .map((k) => userExtensions[k] || allExtensions[k])
            .filter((info) => !!info)
            .reduce((result, info) => util.objectSpread(result, info[type]), {});
    }

    function decodeEvent(registry, value) {
        if (!value?.length) {
            return { DataType: Null };
        }
        const index = value.subarray(0, 2);
        return {
            DataType: registry.findMetaEvent(index),
            value: {
                data: value.subarray(2),
                index
            }
        };
    }
    class GenericEventData extends Tuple {
        __internal__meta;
        __internal__method;
        __internal__names = null;
        __internal__section;
        __internal__typeDef;
        constructor(registry, value, meta, section = '<unknown>', method = '<unknown>') {
            const fields = meta?.fields || [];
            super(registry, fields.map(({ type }) => registry.createLookupType(type)), value);
            this.__internal__meta = meta;
            this.__internal__method = method;
            this.__internal__section = section;
            this.__internal__typeDef = fields.map(({ type }) => registry.lookup.getTypeDef(type));
            const names = fields
                .map(({ name }) => registry.lookup.sanitizeField(name)[0])
                .filter((n) => !!n);
            if (names.length === fields.length) {
                this.__internal__names = names;
                util.objectProperties(this, names, (_, i) => this[i]);
            }
        }
        get meta() {
            return this.__internal__meta;
        }
        get method() {
            return this.__internal__method;
        }
        get names() {
            return this.__internal__names;
        }
        get section() {
            return this.__internal__section;
        }
        get typeDef() {
            return this.__internal__typeDef;
        }
        toHuman(isExtended) {
            if (this.__internal__names !== null) {
                const json = {};
                for (let i = 0, count = this.__internal__names.length; i < count; i++) {
                    json[this.__internal__names[i]] = this[i].toHuman(isExtended);
                }
                return json;
            }
            return super.toHuman(isExtended);
        }
    }
    class GenericEvent extends Struct {
        constructor(registry, _value) {
            const { DataType, value } = decodeEvent(registry, _value);
            super(registry, {
                index: 'EventId',
                data: DataType
            }, value);
        }
        get data() {
            return this.getT('data');
        }
        get index() {
            return this.getT('index');
        }
        get meta() {
            return this.data.meta;
        }
        get method() {
            return this.data.method;
        }
        get section() {
            return this.data.section;
        }
        get typeDef() {
            return this.data.typeDef;
        }
        toHuman(isExpanded) {
            return util.objectSpread({
                method: this.method,
                section: this.section
            }, isExpanded
                ? { docs: this.meta.docs.map((d) => d.toString()) }
                : null, super.toHuman(isExpanded));
        }
    }

    const EXTRINSIC_VERSION = 4;
    class GenericExtrinsicV4 extends Struct {
        constructor(registry, value, { isSigned } = {}) {
            super(registry, {
                signature: 'ExtrinsicSignatureV4',
                method: 'Call'
            }, GenericExtrinsicV4.decodeExtrinsic(registry, value, isSigned));
        }
        static decodeExtrinsic(registry, value, isSigned = false) {
            if (value instanceof GenericExtrinsicV4) {
                return value;
            }
            else if (value instanceof registry.createClassUnsafe('Call')) {
                return { method: value };
            }
            else if (util.isU8a(value)) {
                const signature = registry.createTypeUnsafe('ExtrinsicSignatureV4', [value, { isSigned }]);
                const method = registry.createTypeUnsafe('Call', [value.subarray(signature.encodedLength)]);
                return {
                    method,
                    signature
                };
            }
            return value || {};
        }
        get encodedLength() {
            return this.toU8a().length;
        }
        get method() {
            return this.getT('method');
        }
        get signature() {
            return this.getT('signature');
        }
        get version() {
            return EXTRINSIC_VERSION;
        }
        addSignature(signer, signature, payload) {
            this.signature.addSignature(signer, signature, payload);
            return this;
        }
        sign(account, options) {
            this.signature.sign(this.method, account, options);
            return this;
        }
        signFake(signer, options) {
            this.signature.signFake(this.method, signer, options);
            return this;
        }
    }

    const BIT_SIGNED = 0b10000000;
    const BIT_UNSIGNED = 0;
    const EMPTY_U8A = new Uint8Array();
    const DEFAULT_VERSION = 4;
    const IMMORTAL_ERA = new Uint8Array([0]);
    const UNMASK_VERSION = 0b01111111;

    const VERSIONS$1 = [
        'ExtrinsicUnknown',
        'ExtrinsicUnknown',
        'ExtrinsicUnknown',
        'ExtrinsicUnknown',
        'ExtrinsicV4'
    ];
    function newFromValue(registry, value, version) {
        if (value instanceof GenericExtrinsic) {
            return value.unwrap();
        }
        const isSigned = (version & BIT_SIGNED) === BIT_SIGNED;
        const type = VERSIONS$1[version & UNMASK_VERSION] || VERSIONS$1[0];
        return registry.createTypeUnsafe(type, [value, { isSigned, version }]);
    }
    function decodeExtrinsic(registry, value, version = DEFAULT_VERSION) {
        if (util.isU8a(value) || Array.isArray(value) || util.isHex(value)) {
            return decodeU8a$4(registry, util.u8aToU8a(value), version);
        }
        else if (value instanceof registry.createClassUnsafe('Call')) {
            return newFromValue(registry, { method: value }, version);
        }
        return newFromValue(registry, value, version);
    }
    function decodeU8a$4(registry, value, version) {
        if (!value.length) {
            return newFromValue(registry, new Uint8Array(), version);
        }
        const [offset, length] = util.compactFromU8a(value);
        const total = offset + length.toNumber();
        if (total > value.length) {
            throw new Error(`Extrinsic: length less than remainder, expected at least ${total}, found ${value.length}`);
        }
        const data = value.subarray(offset, total);
        return newFromValue(registry, data.subarray(1), data[0]);
    }
    class ExtrinsicBase extends AbstractBase {
        constructor(registry, value, initialU8aLength) {
            super(registry, value, initialU8aLength);
            const signKeys = Object.keys(registry.getSignedExtensionTypes());
            const getter = (key) => this.inner.signature[key];
            for (let i = 0, count = signKeys.length; i < count; i++) {
                util.objectProperty(this, signKeys[i], getter);
            }
        }
        get args() {
            return this.method.args;
        }
        get argsDef() {
            return this.method.argsDef;
        }
        get callIndex() {
            return this.method.callIndex;
        }
        get data() {
            return this.method.data;
        }
        get era() {
            return this.inner.signature.era;
        }
        get encodedLength() {
            return this.toU8a().length;
        }
        get isSigned() {
            return this.inner.signature.isSigned;
        }
        get length() {
            return this.toU8a(true).length;
        }
        get meta() {
            return this.method.meta;
        }
        get method() {
            return this.inner.method;
        }
        get nonce() {
            return this.inner.signature.nonce;
        }
        get signature() {
            return this.inner.signature.signature;
        }
        get signer() {
            return this.inner.signature.signer;
        }
        get tip() {
            return this.inner.signature.tip;
        }
        get type() {
            return this.inner.version;
        }
        get inner() {
            return this.unwrap();
        }
        get version() {
            return this.type | (this.isSigned ? BIT_SIGNED : BIT_UNSIGNED);
        }
        is(other) {
            return this.method.is(other);
        }
        unwrap() {
            return super.unwrap();
        }
    }
    class GenericExtrinsic extends ExtrinsicBase {
        __internal__hashCache;
        static LATEST_EXTRINSIC_VERSION = EXTRINSIC_VERSION;
        constructor(registry, value, { version } = {}) {
            super(registry, decodeExtrinsic(registry, value, version));
        }
        get hash() {
            if (!this.__internal__hashCache) {
                this.__internal__hashCache = super.hash;
            }
            return this.__internal__hashCache;
        }
        addSignature(signer, signature, payload) {
            this.inner.addSignature(signer, signature, payload);
            this.__internal__hashCache = undefined;
            return this;
        }
        inspect() {
            const encoded = util.u8aConcat(...this.toU8aInner());
            return {
                inner: this.isSigned
                    ? this.inner.inspect().inner
                    : this.inner.method.inspect().inner,
                outer: [util.compactToU8a(encoded.length), new Uint8Array([this.version])]
            };
        }
        sign(account, options) {
            this.inner.sign(account, options);
            this.__internal__hashCache = undefined;
            return this;
        }
        signFake(signer, options) {
            this.inner.signFake(signer, options);
            this.__internal__hashCache = undefined;
            return this;
        }
        toHex(isBare) {
            return util.u8aToHex(this.toU8a(isBare));
        }
        toHuman(isExpanded) {
            return util.objectSpread({}, {
                isSigned: this.isSigned,
                method: this.method.toHuman(isExpanded)
            }, this.isSigned
                ? {
                    era: this.era.toHuman(isExpanded),
                    nonce: this.nonce.toHuman(isExpanded),
                    signature: this.signature.toHex(),
                    signer: this.signer.toHuman(isExpanded),
                    tip: this.tip.toHuman(isExpanded)
                }
                : null);
        }
        toJSON() {
            return this.toHex();
        }
        toRawType() {
            return 'Extrinsic';
        }
        toU8a(isBare) {
            const encoded = util.u8aConcat(...this.toU8aInner());
            return isBare
                ? encoded
                : util.compactAddLength(encoded);
        }
        toU8aInner() {
            return [
                new Uint8Array([this.version]),
                this.inner.toU8a()
            ];
        }
    }

    function getTrailingZeros(period) {
        const binary = period.toString(2);
        let index = 0;
        while (binary[binary.length - 1 - index] === '0') {
            index++;
        }
        return index;
    }
    function decodeMortalEra(registry, value) {
        if (util.isU8a(value) || util.isHex(value) || Array.isArray(value)) {
            return decodeMortalU8a(registry, util.u8aToU8a(value));
        }
        else if (!value) {
            return [new u64(registry), new u64(registry)];
        }
        else if (util.isObject(value)) {
            return decodeMortalObject(registry, value);
        }
        throw new Error('Invalid data passed to Mortal era');
    }
    function decodeMortalObject(registry, value) {
        const { current, period } = value;
        let calPeriod = Math.pow(2, Math.ceil(Math.log2(period)));
        calPeriod = Math.min(Math.max(calPeriod, 4), 1 << 16);
        const phase = current % calPeriod;
        const quantizeFactor = Math.max(calPeriod >> 12, 1);
        const quantizedPhase = phase / quantizeFactor * quantizeFactor;
        return [new u64(registry, calPeriod), new u64(registry, quantizedPhase)];
    }
    function decodeMortalU8a(registry, value) {
        if (value.length === 0) {
            return [new u64(registry), new u64(registry)];
        }
        const first = util.u8aToBn(value.subarray(0, 1)).toNumber();
        const second = util.u8aToBn(value.subarray(1, 2)).toNumber();
        const encoded = first + (second << 8);
        const period = 2 << (encoded % (1 << 4));
        const quantizeFactor = Math.max(period >> 12, 1);
        const phase = (encoded >> 4) * quantizeFactor;
        if (period < 4 || phase >= period) {
            throw new Error('Invalid data passed to Mortal era');
        }
        return [new u64(registry, period), new u64(registry, phase)];
    }
    function decodeExtrinsicEra(value = new Uint8Array()) {
        if (util.isU8a(value)) {
            return (!value.length || value[0] === 0)
                ? new Uint8Array([0])
                : new Uint8Array([1, value[0], value[1]]);
        }
        else if (!value) {
            return new Uint8Array([0]);
        }
        else if (value instanceof GenericExtrinsicEra) {
            return decodeExtrinsicEra(value.toU8a());
        }
        else if (util.isHex(value)) {
            return decodeExtrinsicEra(util.hexToU8a(value));
        }
        else if (util.isObject(value)) {
            const entries = Object.entries(value).map(([k, v]) => [k.toLowerCase(), v]);
            const mortal = entries.find(([k]) => k.toLowerCase() === 'mortalera');
            const immortal = entries.find(([k]) => k.toLowerCase() === 'immortalera');
            return mortal
                ? { MortalEra: mortal[1] }
                : immortal
                    ? { ImmortalEra: immortal[1] }
                    : { MortalEra: value };
        }
        throw new Error('Invalid data passed to Era');
    }
    class ImmortalEra extends Raw {
        constructor(registry, _value) {
            super(registry, IMMORTAL_ERA);
        }
    }
    class MortalEra extends Tuple {
        constructor(registry, value) {
            super(registry, {
                period: u64,
                phase: u64
            }, decodeMortalEra(registry, value));
        }
        get encodedLength() {
            return 2 | 0;
        }
        get period() {
            return this[0];
        }
        get phase() {
            return this[1];
        }
        toHuman() {
            return {
                period: util.formatNumber(this.period),
                phase: util.formatNumber(this.phase)
            };
        }
        toJSON() {
            return this.toHex();
        }
        toU8a(_isBare) {
            const period = this.period.toNumber();
            const encoded = Math.min(15, Math.max(1, getTrailingZeros(period) - 1)) + ((this.phase.toNumber() / Math.max(period >> 12, 1)) << 4);
            return new Uint8Array([
                encoded & 0xff,
                encoded >> 8
            ]);
        }
        birth(current) {
            const phase = this.phase.toNumber();
            const period = this.period.toNumber();
            return (~~((Math.max(util.bnToBn(current).toNumber(), phase) - phase) / period) * period) + phase;
        }
        death(current) {
            return this.birth(current) + this.period.toNumber();
        }
    }
    class GenericExtrinsicEra extends Enum {
        constructor(registry, value) {
            super(registry, {
                ImmortalEra,
                MortalEra
            }, decodeExtrinsicEra(value));
        }
        get encodedLength() {
            return this.isImmortalEra
                ? this.asImmortalEra.encodedLength
                : this.asMortalEra.encodedLength;
        }
        get asImmortalEra() {
            if (!this.isImmortalEra) {
                throw new Error(`Cannot convert '${this.type}' via asImmortalEra`);
            }
            return this.inner;
        }
        get asMortalEra() {
            if (!this.isMortalEra) {
                throw new Error(`Cannot convert '${this.type}' via asMortalEra`);
            }
            return this.inner;
        }
        get isImmortalEra() {
            return this.index === 0;
        }
        get isMortalEra() {
            return this.index > 0;
        }
        toU8a(isBare) {
            return this.isMortalEra
                ? this.asMortalEra.toU8a(isBare)
                : this.asImmortalEra.toU8a(isBare);
        }
    }

    const VERSIONS = [
        'ExtrinsicPayloadUnknown',
        'ExtrinsicPayloadUnknown',
        'ExtrinsicPayloadUnknown',
        'ExtrinsicPayloadUnknown',
        'ExtrinsicPayloadV4'
    ];
    function decodeExtrinsicPayload(registry, value, version = DEFAULT_VERSION) {
        if (value instanceof GenericExtrinsicPayload) {
            return value.unwrap();
        }
        return registry.createTypeUnsafe(VERSIONS[version] || VERSIONS[0], [value, { version }]);
    }
    class GenericExtrinsicPayload extends AbstractBase {
        constructor(registry, value, { version } = {}) {
            super(registry, decodeExtrinsicPayload(registry, value, version));
        }
        get blockHash() {
            return this.inner.blockHash;
        }
        get era() {
            return this.inner.era;
        }
        get genesisHash() {
            return this.inner.genesisHash || this.registry.createTypeUnsafe('Hash', []);
        }
        get method() {
            return this.inner.method;
        }
        get nonce() {
            return this.inner.nonce;
        }
        get specVersion() {
            return this.inner.specVersion || this.registry.createTypeUnsafe('u32', []);
        }
        get tip() {
            return this.inner.tip || this.registry.createTypeUnsafe('Compact<Balance>', []);
        }
        get transactionVersion() {
            return this.inner.transactionVersion || this.registry.createTypeUnsafe('u32', []);
        }
        eq(other) {
            return this.inner.eq(other);
        }
        sign(signerPair) {
            const signature = this.inner.sign(signerPair);
            return {
                signature: util.u8aToHex(signature)
            };
        }
        toHuman(isExtended) {
            return this.inner.toHuman(isExtended);
        }
        toJSON() {
            return this.toHex();
        }
        toRawType() {
            return 'ExtrinsicPayload';
        }
        toString() {
            return this.toHex();
        }
        toU8a(isBare) {
            return super.toU8a(isBare ? { method: true } : false);
        }
    }

    class GenericExtrinsicPayloadUnknown extends Struct {
        constructor(registry, _value, { version = 0 } = {}) {
            super(registry, {});
            throw new Error(`Unsupported extrinsic payload version ${version}`);
        }
    }

    class GenericExtrinsicUnknown extends Struct {
        constructor(registry, _value, { isSigned = false, version = 0 } = {}) {
            super(registry, {});
            throw new Error(`Unsupported ${isSigned ? '' : 'un'}signed extrinsic version ${version & UNMASK_VERSION}`);
        }
    }

    const knownTypes = {
        address: 'Address',
        blockHash: 'Hash',
        blockNumber: 'BlockNumber',
        era: 'ExtrinsicEra',
        genesisHash: 'Hash',
        method: 'Call',
        nonce: 'Compact<Index>',
        runtimeVersion: 'RuntimeVersion',
        signedExtensions: 'Vec<Text>',
        tip: 'Compact<Balance>',
        version: 'u8'
    };
    class GenericSignerPayload extends Struct {
        __internal__extraTypes;
        constructor(registry, value) {
            const extensionTypes = util.objectSpread({}, registry.getSignedExtensionTypes(), registry.getSignedExtensionExtra());
            super(registry, util.objectSpread({}, extensionTypes, knownTypes), value);
            this.__internal__extraTypes = {};
            const getter = (key) => this.get(key);
            for (const [key, type] of Object.entries(extensionTypes)) {
                if (!knownTypes[key]) {
                    this.__internal__extraTypes[key] = type;
                }
                util.objectProperty(this, key, getter);
            }
        }
        get address() {
            return this.getT('address');
        }
        get blockHash() {
            return this.getT('blockHash');
        }
        get blockNumber() {
            return this.getT('blockNumber');
        }
        get era() {
            return this.getT('era');
        }
        get genesisHash() {
            return this.getT('genesisHash');
        }
        get method() {
            return this.getT('method');
        }
        get nonce() {
            return this.getT('nonce');
        }
        get runtimeVersion() {
            return this.getT('runtimeVersion');
        }
        get signedExtensions() {
            return this.getT('signedExtensions');
        }
        get tip() {
            return this.getT('tip');
        }
        get version() {
            return this.getT('version');
        }
        toPayload() {
            const result = {};
            const keys = Object.keys(this.__internal__extraTypes);
            for (let i = 0, count = keys.length; i < count; i++) {
                const key = keys[i];
                const value = this.getT(key);
                if (!(value instanceof Option) || value.isSome) {
                    result[key] = value.toJSON();
                }
            }
            return util.objectSpread(result, {
                address: this.address.toString(),
                blockHash: this.blockHash.toHex(),
                blockNumber: this.blockNumber.toHex(),
                era: this.era.toHex(),
                genesisHash: this.genesisHash.toHex(),
                method: this.method.toHex(),
                nonce: this.nonce.toHex(),
                signedExtensions: this.signedExtensions.map((e) => e.toString()),
                specVersion: this.runtimeVersion.specVersion.toHex(),
                tip: this.tip.toHex(),
                transactionVersion: this.runtimeVersion.transactionVersion.toHex(),
                version: this.version.toNumber()
            });
        }
        toRaw() {
            const payload = this.toPayload();
            const data = util.u8aToHex(this.registry
                .createTypeUnsafe('ExtrinsicPayload', [payload, { version: payload.version }])
                .toU8a({ method: true }));
            return {
                address: payload.address,
                data,
                type: 'payload'
            };
        }
    }

    function sign(registry, signerPair, u8a, options) {
        const encoded = u8a.length > 256
            ? registry.hash(u8a)
            : u8a;
        return signerPair.sign(encoded, options);
    }

    class GenericExtrinsicPayloadV4 extends Struct {
        __internal__signOptions;
        constructor(registry, value) {
            super(registry, util.objectSpread({ method: 'Bytes' }, registry.getSignedExtensionTypes(), registry.getSignedExtensionExtra()), value);
            this.__internal__signOptions = {
                withType: registry.createTypeUnsafe('ExtrinsicSignature', []) instanceof Enum
            };
        }
        inspect() {
            return super.inspect({ method: true });
        }
        get blockHash() {
            return this.getT('blockHash');
        }
        get era() {
            return this.getT('era');
        }
        get genesisHash() {
            return this.getT('genesisHash');
        }
        get method() {
            return this.getT('method');
        }
        get nonce() {
            return this.getT('nonce');
        }
        get specVersion() {
            return this.getT('specVersion');
        }
        get tip() {
            return this.getT('tip');
        }
        get transactionVersion() {
            return this.getT('transactionVersion');
        }
        get assetId() {
            return this.getT('assetId');
        }
        sign(signerPair) {
            return sign(this.registry, signerPair, this.toU8a({ method: true }), this.__internal__signOptions);
        }
    }

    const FAKE_SIGNATURE = new Uint8Array(256).fill(1);
    function toAddress(registry, address) {
        return registry.createTypeUnsafe('Address', [util.isU8a(address) ? util.u8aToHex(address) : address]);
    }
    class GenericExtrinsicSignatureV4 extends Struct {
        __internal__signKeys;
        constructor(registry, value, { isSigned } = {}) {
            const signTypes = registry.getSignedExtensionTypes();
            super(registry, util.objectSpread(
            { signer: 'Address', signature: 'ExtrinsicSignature' }, signTypes), GenericExtrinsicSignatureV4.decodeExtrinsicSignature(value, isSigned));
            this.__internal__signKeys = Object.keys(signTypes);
            util.objectProperties(this, this.__internal__signKeys, (k) => this.get(k));
        }
        static decodeExtrinsicSignature(value, isSigned = false) {
            if (!value) {
                return EMPTY_U8A;
            }
            else if (value instanceof GenericExtrinsicSignatureV4) {
                return value;
            }
            return isSigned
                ? value
                : EMPTY_U8A;
        }
        get encodedLength() {
            return this.isSigned
                ? super.encodedLength
                : 0;
        }
        get isSigned() {
            return !this.signature.isEmpty;
        }
        get era() {
            return this.getT('era');
        }
        get nonce() {
            return this.getT('nonce');
        }
        get signature() {
            return (this.multiSignature.value || this.multiSignature);
        }
        get multiSignature() {
            return this.getT('signature');
        }
        get signer() {
            return this.getT('signer');
        }
        get tip() {
            return this.getT('tip');
        }
        _injectSignature(signer, signature, payload) {
            for (let i = 0, count = this.__internal__signKeys.length; i < count; i++) {
                const k = this.__internal__signKeys[i];
                const v = payload.get(k);
                if (!util.isUndefined(v)) {
                    this.set(k, v);
                }
            }
            this.set('signer', signer);
            this.set('signature', signature);
            return this;
        }
        addSignature(signer, signature, payload) {
            return this._injectSignature(toAddress(this.registry, signer), this.registry.createTypeUnsafe('ExtrinsicSignature', [signature]), new GenericExtrinsicPayloadV4(this.registry, payload));
        }
        createPayload(method, options) {
            const { era, runtimeVersion: { specVersion, transactionVersion } } = options;
            return new GenericExtrinsicPayloadV4(this.registry, util.objectSpread({}, options, {
                era: era || IMMORTAL_ERA,
                method: method.toHex(),
                specVersion,
                transactionVersion
            }));
        }
        sign(method, account, options) {
            if (!account?.addressRaw) {
                throw new Error(`Expected a valid keypair for signing, found ${util.stringify(account)}`);
            }
            const payload = this.createPayload(method, options);
            return this._injectSignature(toAddress(this.registry, account.addressRaw), this.registry.createTypeUnsafe('ExtrinsicSignature', [payload.sign(account)]), payload);
        }
        signFake(method, address, options) {
            if (!address) {
                throw new Error(`Expected a valid address for signing, found ${util.stringify(address)}`);
            }
            const payload = this.createPayload(method, options);
            return this._injectSignature(toAddress(this.registry, address), this.registry.createTypeUnsafe('ExtrinsicSignature', [FAKE_SIGNATURE]), payload);
        }
        toU8a(isBare) {
            return this.isSigned
                ? super.toU8a(isBare)
                : EMPTY_U8A;
        }
    }

    function decodeAccountId$1(value) {
        if (util.isU8a(value) || Array.isArray(value)) {
            return util.u8aToU8a(value);
        }
        else if (!value) {
            return new Uint8Array();
        }
        else if (util.isHex(value)) {
            return util.hexToU8a(value);
        }
        else if (util.isString(value)) {
            return utilCrypto.decodeAddress(value.toString());
        }
        throw new Error(`Unknown type passed to AccountId constructor, found typeof ${typeof value}`);
    }
    class BaseAccountId extends U8aFixed {
        constructor(registry, allowedBits = 256 | 264, value) {
            const decoded = decodeAccountId$1(value);
            const decodedBits = decoded.length * 8;
            if (decodedBits < allowedBits && decoded.some((b) => b)) {
                throw new Error(`Invalid AccountId provided, expected ${allowedBits >> 3} bytes, found ${decoded.length}`);
            }
            super(registry, decoded, allowedBits);
        }
        eq(other) {
            return super.eq(decodeAccountId$1(other));
        }
        toHuman() {
            return this.toJSON();
        }
        toJSON() {
            return this.toString();
        }
        toPrimitive() {
            return this.toJSON();
        }
        toString() {
            return utilCrypto.encodeAddress(this, this.registry.chainSS58);
        }
        toRawType() {
            return 'AccountId';
        }
    }
    class GenericAccountId extends BaseAccountId {
        constructor(registry, value) {
            super(registry, 256, value);
        }
    }
    class GenericAccountId33 extends BaseAccountId {
        constructor(registry, value) {
            super(registry, 264, value);
        }
    }

    const PREFIX_1BYTE = 0xef;
    const PREFIX_2BYTE = 0xfc;
    const PREFIX_4BYTE = 0xfd;
    const PREFIX_8BYTE = 0xfe;
    const MAX_1BYTE = new util.BN(PREFIX_1BYTE);
    const MAX_2BYTE = new util.BN(1).shln(16);
    const MAX_4BYTE = new util.BN(1).shln(32);
    function decodeAccountIndex(value) {
        if (value instanceof GenericAccountIndex) {
            return value.toBn();
        }
        else if (util.isBn(value) || util.isNumber(value) || util.isHex(value) || util.isU8a(value) || util.isBigInt(value)) {
            return value;
        }
        return decodeAccountIndex(utilCrypto.decodeAddress(value));
    }
    class GenericAccountIndex extends u32 {
        constructor(registry, value = new util.BN(0)) {
            super(registry, decodeAccountIndex(value));
        }
        static calcLength(_value) {
            const value = util.bnToBn(_value);
            if (value.lte(MAX_1BYTE)) {
                return 1;
            }
            else if (value.lt(MAX_2BYTE)) {
                return 2;
            }
            else if (value.lt(MAX_4BYTE)) {
                return 4;
            }
            return 8;
        }
        static readLength(input) {
            const first = input[0];
            if (first === PREFIX_2BYTE) {
                return [1, 2];
            }
            else if (first === PREFIX_4BYTE) {
                return [1, 4];
            }
            else if (first === PREFIX_8BYTE) {
                return [1, 8];
            }
            return [0, 1];
        }
        static writeLength(input) {
            switch (input.length) {
                case 2: return new Uint8Array([PREFIX_2BYTE]);
                case 4: return new Uint8Array([PREFIX_4BYTE]);
                case 8: return new Uint8Array([PREFIX_8BYTE]);
                default: return new Uint8Array([]);
            }
        }
        eq(other) {
            if (util.isBn(other) || util.isNumber(other)) {
                return super.eq(other);
            }
            return super.eq(this.registry.createTypeUnsafe('AccountIndex', [other]));
        }
        toHuman() {
            return this.toJSON();
        }
        toJSON() {
            return this.toString();
        }
        toPrimitive() {
            return this.toJSON();
        }
        toString() {
            const length = GenericAccountIndex.calcLength(this);
            return utilCrypto.encodeAddress(this.toU8a().subarray(0, length), this.registry.chainSS58);
        }
        toRawType() {
            return 'AccountIndex';
        }
    }

    class GenericBlock extends Struct {
        constructor(registry, value) {
            super(registry, {
                header: 'Header',
                extrinsics: 'Vec<Extrinsic>'
            }, value);
        }
        get contentHash() {
            return this.registry.hash(this.toU8a());
        }
        get extrinsics() {
            return this.getT('extrinsics');
        }
        get hash() {
            return this.header.hash;
        }
        get header() {
            return this.getT('header');
        }
    }

    function getArgsDef(registry, meta) {
        return meta.fields.reduce((result, { name, type }, index) => {
            result[name.unwrapOr(`param${index}`).toString()] = registry.createLookupType(type);
            return result;
        }, {});
    }
    function decodeCallViaObject(registry, value, _meta) {
        const { args, callIndex } = value;
        const lookupIndex = callIndex instanceof GenericCallIndex
            ? callIndex.toU8a()
            : callIndex;
        const meta = _meta || registry.findMetaCall(lookupIndex).meta;
        return {
            args,
            argsDef: getArgsDef(registry, meta),
            callIndex,
            meta
        };
    }
    function decodeCallViaU8a(registry, value, _meta) {
        const callIndex = registry.firstCallIndex.slice();
        callIndex.set(value.subarray(0, 2), 0);
        const meta = _meta || registry.findMetaCall(callIndex).meta;
        return {
            args: value.subarray(2),
            argsDef: getArgsDef(registry, meta),
            callIndex,
            meta
        };
    }
    function decodeCall(registry, value = new Uint8Array(), _meta) {
        if (util.isU8a(value) || util.isHex(value)) {
            return decodeCallViaU8a(registry, util.u8aToU8a(value), _meta);
        }
        else if (util.isObject(value) && value.callIndex && value.args) {
            return decodeCallViaObject(registry, value, _meta);
        }
        throw new Error(`Call: Cannot decode value '${value}' of type ${typeof value}`);
    }
    class GenericCallIndex extends U8aFixed {
        constructor(registry, value) {
            super(registry, value, 16);
        }
        toPrimitive() {
            return this.toHex();
        }
    }
    class GenericCall extends Struct {
        _meta;
        constructor(registry, value, meta) {
            const decoded = decodeCall(registry, value, meta);
            try {
                super(registry, {
                    callIndex: GenericCallIndex,
                    args: Struct.with(decoded.argsDef)
                }, decoded);
            }
            catch (error) {
                let method = 'unknown.unknown';
                try {
                    const c = registry.findMetaCall(decoded.callIndex);
                    method = `${c.section}.${c.method}`;
                }
                catch {
                }
                throw new Error(`Call: failed decoding ${method}:: ${error.message}`);
            }
            this._meta = decoded.meta;
        }
        get args() {
            return [...this.getT('args').values()];
        }
        get argsDef() {
            return getArgsDef(this.registry, this.meta);
        }
        get argsEntries() {
            return [...this.getT('args').entries()];
        }
        get callIndex() {
            return this.getT('callIndex').toU8a();
        }
        get data() {
            return this.getT('args').toU8a();
        }
        get meta() {
            return this._meta;
        }
        get method() {
            return this.registry.findMetaCall(this.callIndex).method;
        }
        get section() {
            return this.registry.findMetaCall(this.callIndex).section;
        }
        is(other) {
            return other.callIndex[0] === this.callIndex[0] && other.callIndex[1] === this.callIndex[1];
        }
        toHuman(isExpanded) {
            let call;
            try {
                call = this.registry.findMetaCall(this.callIndex);
            }
            catch {
            }
            return util.objectSpread({
                args: this.argsEntries.reduce((args, [n, a]) => util.objectSpread(args, { [n]: a.toHuman(isExpanded) }), {}),
                method: call?.method,
                section: call?.section
            }, isExpanded && call
                ? { docs: call.meta.docs.map((d) => d.toString()) }
                : null);
        }
        toRawType() {
            return 'Call';
        }
    }

    function createValue(registry, type, value, asArray = true) {
        if (value && util.isFunction(value.unwrapOrDefault)) {
            return value;
        }
        return registry.createTypeUnsafe(type, [
            asArray
                ? util.isNull(value) || util.isUndefined(value)
                    ? null
                    : Array.isArray(value)
                        ? value
                        : [value]
                : value
        ]);
    }
    function decodeValue(registry, key, value) {
        return key === 'ss58Format'
            ? createValue(registry, 'Option<u32>', value, false)
            : key === 'tokenDecimals'
                ? createValue(registry, 'Option<Vec<u32>>', value)
                : key === 'tokenSymbol'
                    ? createValue(registry, 'Option<Vec<Text>>', value)
                    : key === 'isEthereum'
                        ? createValue(registry, 'Bool', value, false)
                        : value;
    }
    function decode(registry, value) {
        return (
        value && util.isFunction(value.entries)
            ? [...value.entries()]
            : Object.entries(value || {})).reduce((all, [key, value]) => {
            all[key] = decodeValue(registry, key, value);
            return all;
        }, {
            isEthereum: registry.createTypeUnsafe('Bool', []),
            ss58Format: registry.createTypeUnsafe('Option<u32>', []),
            tokenDecimals: registry.createTypeUnsafe('Option<Vec<u32>>', []),
            tokenSymbol: registry.createTypeUnsafe('Option<Vec<Text>>', [])
        });
    }
    class GenericChainProperties extends Json {
        constructor(registry, value) {
            super(registry, decode(registry, value));
        }
        get isEthereum() {
            return this.getT('isEthereum');
        }
        get ss58Format() {
            return this.getT('ss58Format');
        }
        get tokenDecimals() {
            return this.getT('tokenDecimals');
        }
        get tokenSymbol() {
            return this.getT('tokenSymbol');
        }
    }

    const CID_AURA =  util.stringToU8a('aura');
    const CID_BABE =  util.stringToU8a('BABE');
    const CID_GRPA =  util.stringToU8a('FRNK');
    const CID_POW =  util.stringToU8a('pow_');
    const CID_NMBS =  util.stringToU8a('nmbs');
    function getAuraAuthor(registry, bytes, sessionValidators) {
        return sessionValidators[registry.createTypeUnsafe('RawAuraPreDigest', [bytes.toU8a(true)])
            .slotNumber
            .mod(new util.BN(sessionValidators.length))
            .toNumber()];
    }
    function getBabeAuthor(registry, bytes, sessionValidators) {
        const digest = registry.createTypeUnsafe('RawBabePreDigestCompat', [bytes.toU8a(true)]);
        return sessionValidators[digest.value.toNumber()];
    }
    function getBytesAsAuthor(registry, bytes) {
        return registry.createTypeUnsafe('AccountId', [bytes]);
    }
    class GenericConsensusEngineId extends U8aFixed {
        constructor(registry, value) {
            super(registry, util.isNumber(value)
                ? util.bnToU8a(value, { isLe: false })
                : value, 32);
        }
        get isAura() {
            return this.eq(CID_AURA);
        }
        get isBabe() {
            return this.eq(CID_BABE);
        }
        get isGrandpa() {
            return this.eq(CID_GRPA);
        }
        get isPow() {
            return this.eq(CID_POW);
        }
        get isNimbus() {
            return this.eq(CID_NMBS);
        }
        extractAuthor(bytes, sessionValidators) {
            if (sessionValidators?.length) {
                if (this.isAura) {
                    return getAuraAuthor(this.registry, bytes, sessionValidators);
                }
                else if (this.isBabe) {
                    return getBabeAuthor(this.registry, bytes, sessionValidators);
                }
            }
            if (this.isPow || this.isNimbus) {
                return getBytesAsAuthor(this.registry, bytes);
            }
            return undefined;
        }
        toHuman() {
            return this.toString();
        }
        toRawType() {
            return 'ConsensusEngineId';
        }
        toString() {
            return this.isAscii
                ? util.u8aToString(this)
                : util.u8aToHex(this);
        }
    }

    const ACCOUNT_ID_PREFIX$1 = new Uint8Array([0xff]);
    function decodeString$1(registry, value) {
        const decoded = utilCrypto.decodeAddress(value);
        return decoded.length === 32
            ? registry.createTypeUnsafe('AccountId', [decoded])
            : registry.createTypeUnsafe('AccountIndex', [util.u8aToBn(decoded)]);
    }
    function decodeU8a$3(registry, value) {
        if (value.length === 32) {
            return registry.createTypeUnsafe('AccountId', [value]);
        }
        else if (value[0] === 0xff) {
            return registry.createTypeUnsafe('AccountId', [value.subarray(1)]);
        }
        const [offset, length] = GenericAccountIndex.readLength(value);
        return registry.createTypeUnsafe('AccountIndex', [util.u8aToBn(value.subarray(offset, offset + length))]);
    }
    function decodeAddressOrIndex$1(registry, value) {
        return value instanceof GenericLookupSource
            ? value.inner
            : value instanceof GenericAccountId || value instanceof GenericAccountIndex
                ? value
                : util.isBn(value) || util.isNumber(value) || util.isBigInt(value)
                    ? registry.createTypeUnsafe('AccountIndex', [value])
                    : Array.isArray(value) || util.isHex(value) || util.isU8a(value)
                        ? decodeU8a$3(registry, util.u8aToU8a(value))
                        : decodeString$1(registry, value);
    }
    class GenericLookupSource extends AbstractBase {
        constructor(registry, value = new Uint8Array()) {
            super(registry, decodeAddressOrIndex$1(registry, value));
        }
        get encodedLength() {
            const rawLength = this._rawLength;
            return rawLength + (
            rawLength > 1
                ? 1
                : 0);
        }
        get _rawLength() {
            return this.inner instanceof GenericAccountIndex
                ? GenericAccountIndex.calcLength(this.inner)
                : this.inner.encodedLength;
        }
        inspect() {
            const value = this.inner.toU8a().subarray(0, this._rawLength);
            return {
                outer: [
                    new Uint8Array(this.inner instanceof GenericAccountIndex
                        ? GenericAccountIndex.writeLength(value)
                        : ACCOUNT_ID_PREFIX$1),
                    value
                ]
            };
        }
        toHex() {
            return util.u8aToHex(this.toU8a());
        }
        toRawType() {
            return 'Address';
        }
        toU8a(isBare) {
            const encoded = this.inner.toU8a().subarray(0, this._rawLength);
            return isBare
                ? encoded
                : util.u8aConcat(this.inner instanceof GenericAccountIndex
                    ? GenericAccountIndex.writeLength(encoded)
                    : ACCOUNT_ID_PREFIX$1, encoded);
        }
    }

    function decodeU8a$2(registry, u8a) {
        if ([0, 32].includes(u8a.length)) {
            return { Id: u8a };
        }
        else if (u8a.length === 20) {
            return { Address20: u8a };
        }
        else if (u8a.length <= 8) {
            return { Index: registry.createTypeUnsafe('AccountIndex', [u8a]).toNumber() };
        }
        return u8a;
    }
    function decodeMultiAny(registry, value) {
        if (value instanceof GenericAccountId) {
            return { Id: value };
        }
        else if (util.isU8a(value)) {
            return decodeU8a$2(registry, value);
        }
        else if (value instanceof GenericMultiAddress) {
            return value;
        }
        else if (value instanceof GenericAccountIndex || util.isBn(value) || util.isNumber(value)) {
            return { Index: util.isNumber(value) ? value : value.toNumber() };
        }
        else if (util.isString(value)) {
            return decodeU8a$2(registry, utilCrypto.decodeAddress(value.toString()));
        }
        return value;
    }
    class GenericMultiAddress extends Enum {
        constructor(registry, value) {
            super(registry, {
                Id: 'AccountId',
                Index: 'Compact<AccountIndex>',
                Raw: 'Bytes',
                Address32: 'H256',
                Address20: 'H160'
            }, decodeMultiAny(registry, value));
        }
        inspect() {
            const { inner, outer = [] } = this.inner.inspect();
            return {
                inner,
                outer: [new Uint8Array([this.index]), ...outer]
            };
        }
        toString() {
            return this.value.toString();
        }
    }

    const AYE_BITS = 0b10000000;
    const NAY_BITS = 0b00000000;
    const CON_MASK = 0b01111111;
    const DEF_CONV = 0b00000000;
    function decodeVoteBool(value) {
        return value
            ? new Uint8Array([AYE_BITS | DEF_CONV])
            : new Uint8Array([NAY_BITS]);
    }
    function decodeVoteU8a(value) {
        return value.length
            ? value.subarray(0, 1)
            : new Uint8Array([NAY_BITS]);
    }
    function decodeVoteType(registry, value) {
        return new Uint8Array([
            (new bool(registry, value.aye).isTrue
                ? AYE_BITS
                : NAY_BITS) |
                registry.createTypeUnsafe('Conviction', [value.conviction || DEF_CONV]).index
        ]);
    }
    function decodeVote(registry, value) {
        if (util.isU8a(value)) {
            return decodeVoteU8a(value);
        }
        else if (util.isUndefined(value) || value instanceof Boolean || util.isBoolean(value)) {
            return decodeVoteBool(new bool(registry, value).isTrue);
        }
        else if (util.isNumber(value)) {
            return decodeVoteBool(value < 0);
        }
        return decodeVoteType(registry, value);
    }
    class GenericVote extends U8aFixed {
        __internal__aye;
        __internal__conviction;
        constructor(registry, value) {
            const decoded = decodeVote(registry, value);
            super(registry, decoded, 8);
            this.__internal__aye = (decoded[0] & AYE_BITS) === AYE_BITS;
            this.__internal__conviction = this.registry.createTypeUnsafe('Conviction', [decoded[0] & CON_MASK]);
        }
        get conviction() {
            return this.__internal__conviction;
        }
        get isAye() {
            return this.__internal__aye;
        }
        get isNay() {
            return !this.isAye;
        }
        toHuman(isExpanded) {
            return {
                conviction: this.conviction.toHuman(isExpanded),
                vote: this.isAye ? 'Aye' : 'Nay'
            };
        }
        toPrimitive() {
            return {
                aye: this.isAye,
                conviction: this.conviction.toPrimitive()
            };
        }
        toRawType() {
            return 'Vote';
        }
    }

    function decodeAccountId(value) {
        if (util.isU8a(value) || Array.isArray(value)) {
            return util.u8aToU8a(value);
        }
        else if (util.isHex(value) || utilCrypto.isEthereumAddress(value.toString())) {
            return util.hexToU8a(value.toString());
        }
        else if (util.isString(value)) {
            return util.u8aToU8a(value);
        }
        return value;
    }
    class GenericEthereumAccountId extends U8aFixed {
        constructor(registry, value = new Uint8Array()) {
            super(registry, decodeAccountId(value), 160);
        }
        eq(other) {
            return !!other && super.eq(decodeAccountId(other));
        }
        toHuman() {
            return this.toJSON();
        }
        toJSON() {
            return this.toString();
        }
        toPrimitive() {
            return this.toJSON();
        }
        toString() {
            return utilCrypto.ethereumEncode(this);
        }
        toRawType() {
            return 'AccountId';
        }
    }

    const ACCOUNT_ID_PREFIX = new Uint8Array([0xff]);
    function decodeString(registry, value) {
        const decoded = utilCrypto.decodeAddress(value);
        return decoded.length === 20
            ? registry.createTypeUnsafe('EthereumAccountId', [decoded])
            : registry.createTypeUnsafe('AccountIndex', [util.u8aToBn(decoded)]);
    }
    function decodeU8a$1(registry, value) {
        if (value.length === 20) {
            return registry.createTypeUnsafe('EthereumAccountId', [value]);
        }
        else if (value[0] === 0xff) {
            return registry.createTypeUnsafe('EthereumAccountId', [value.subarray(1)]);
        }
        const [offset, length] = GenericAccountIndex.readLength(value);
        return registry.createTypeUnsafe('AccountIndex', [util.u8aToBn(value.subarray(offset, offset + length))]);
    }
    function decodeAddressOrIndex(registry, value) {
        return value instanceof GenericEthereumLookupSource
            ? value.inner
            : value instanceof GenericEthereumAccountId || value instanceof GenericAccountIndex
                ? value
                : util.isU8a(value) || Array.isArray(value) || util.isHex(value)
                    ? decodeU8a$1(registry, util.u8aToU8a(value))
                    : util.isBn(value) || util.isNumber(value) || util.isBigInt(value)
                        ? registry.createTypeUnsafe('AccountIndex', [value])
                        : decodeString(registry, value);
    }
    class GenericEthereumLookupSource extends AbstractBase {
        constructor(registry, value = new Uint8Array()) {
            super(registry, decodeAddressOrIndex(registry, value));
        }
        get encodedLength() {
            const rawLength = this._rawLength;
            return rawLength + (
            rawLength > 1
                ? 1
                : 0);
        }
        get _rawLength() {
            return this.inner instanceof GenericAccountIndex
                ? GenericAccountIndex.calcLength(this.inner)
                : this.inner.encodedLength;
        }
        toHex() {
            return util.u8aToHex(this.toU8a());
        }
        toRawType() {
            return 'Address';
        }
        toU8a(isBare) {
            const encoded = this.inner.toU8a().subarray(0, this._rawLength);
            return isBare
                ? encoded
                : util.u8aConcat(this.inner instanceof GenericAccountIndex
                    ? GenericAccountIndex.writeLength(encoded)
                    : ACCOUNT_ID_PREFIX, encoded);
        }
    }

    function decodeDataU8a(registry, value) {
        const indicator = value[0];
        if (!indicator) {
            return [undefined, undefined];
        }
        else if (indicator >= 1 && indicator <= 33) {
            const length = indicator - 1;
            const data = value.subarray(1, length + 1);
            return [registry.createTypeUnsafe('Raw', [data]), 1];
        }
        else if (indicator >= 34 && indicator <= 37) {
            return [value.subarray(1, 32 + 1), indicator - 32];
        }
        throw new Error(`Unable to decode Data, invalid indicator byte ${indicator}`);
    }
    function decodeData(registry, value) {
        if (util.isU8a(value) || util.isString(value)) {
            return decodeDataU8a(registry, util.u8aToU8a(value));
        }
        else if (!value) {
            return [undefined, undefined];
        }
        return [value, undefined];
    }
    class Data extends Enum {
        constructor(registry, value) {
            super(registry, {
                None: 'Null',
                Raw: 'Bytes',
                BlakeTwo256: 'H256',
                Sha256: 'H256',
                Keccak256: 'H256',
                ShaThree256: 'H256'
            }, ...decodeData(registry, value));
            if (this.isRaw && this.asRaw.length > 32) {
                throw new Error('Data.Raw values are limited to a maximum length of 32 bytes');
            }
        }
        get asBlakeTwo256() {
            return this.value;
        }
        get asKeccak256() {
            return this.value;
        }
        get asRaw() {
            return this.value;
        }
        get asSha256() {
            return this.value;
        }
        get asShaThree256() {
            return this.value;
        }
        get isBlakeTwo256() {
            return this.index === 2;
        }
        get isKeccak256() {
            return this.index === 4;
        }
        get isNone() {
            return this.index === 0;
        }
        get isRaw() {
            return this.index === 1;
        }
        get isSha256() {
            return this.index === 3;
        }
        get isShaThree256() {
            return this.index === 5;
        }
        get encodedLength() {
            return this.toU8a().length;
        }
        toU8a() {
            if (this.index === 0) {
                return new Uint8Array(1);
            }
            else if (this.index === 1) {
                const data = this.value.toU8a(true);
                const length = Math.min(data.length, 32);
                const u8a = new Uint8Array(length + 1);
                u8a.set([length + 1], 0);
                u8a.set(data.subarray(0, length), 1);
                return u8a;
            }
            const u8a = new Uint8Array(33);
            u8a.set([this.index + 32], 0);
            u8a.set(this.value.toU8a(), 1);
            return u8a;
        }
    }

    const HASHER_MAP = {
        Blake2_128: [16, false],
        Blake2_128Concat: [16, true],
        Blake2_256: [32, false],
        Identity: [0, true],
        Twox128: [16, false],
        Twox256: [32, false],
        Twox64Concat: [8, true]
    };
    function decodeStorageKey(value) {
        if (util.isU8a(value) || !value || util.isString(value)) {
            return { key: value };
        }
        else if (value instanceof StorageKey) {
            return {
                key: value,
                method: value.method,
                section: value.section
            };
        }
        else if (util.isFunction(value)) {
            return {
                key: value(),
                method: value.method,
                section: value.section
            };
        }
        else if (Array.isArray(value)) {
            const [fn, args = []] = value;
            if (!util.isFunction(fn)) {
                throw new Error('Expected function input for key construction');
            }
            if (fn.meta && fn.meta.type.isMap) {
                const map = fn.meta.type.asMap;
                if (!Array.isArray(args) || args.length !== map.hashers.length) {
                    throw new Error(`Expected an array of ${map.hashers.length} values as params to a Map query`);
                }
            }
            return {
                key: fn(...args),
                method: fn.method,
                section: fn.section
            };
        }
        throw new Error(`Unable to convert input ${value} to StorageKey`);
    }
    function decodeHashers(registry, value, hashers) {
        let offset = 32;
        const count = hashers.length;
        const result = new Array(count);
        for (let i = 0; i < count; i++) {
            const [hasher, type] = hashers[i];
            const [hashLen, canDecode] = HASHER_MAP[hasher.type];
            const decoded = canDecode
                ? registry.createTypeUnsafe(getSiName(registry.lookup, type), [value.subarray(offset + hashLen)])
                : registry.createTypeUnsafe('Raw', [value.subarray(offset, offset + hashLen)]);
            offset += hashLen + (canDecode ? decoded.encodedLength : 0);
            result[i] = decoded;
        }
        return result;
    }
    function decodeArgsFromMeta(registry, value, meta) {
        if (!meta || !meta.type.isMap) {
            return [];
        }
        const { hashers, key } = meta.type.asMap;
        const keys = hashers.length === 1
            ? [key]
            : registry.lookup.getSiType(key).def.asTuple;
        return decodeHashers(registry, value, hashers.map((h, i) => [h, keys[i]]));
    }
    function getMeta(value) {
        if (value instanceof StorageKey) {
            return value.meta;
        }
        else if (util.isFunction(value)) {
            return value.meta;
        }
        else if (Array.isArray(value)) {
            const [fn] = value;
            return fn.meta;
        }
        return undefined;
    }
    function getType(registry, value) {
        if (value instanceof StorageKey) {
            return value.outputType;
        }
        else if (util.isFunction(value)) {
            return unwrapStorageType(registry, value.meta.type);
        }
        else if (Array.isArray(value)) {
            const [fn] = value;
            if (fn.meta) {
                return unwrapStorageType(registry, fn.meta.type);
            }
        }
        return 'Raw';
    }
    class StorageKey extends Bytes {
        __internal__args;
        __internal__meta;
        __internal__outputType;
        __internal__method;
        __internal__section;
        constructor(registry, value, override = {}) {
            const { key, method, section } = decodeStorageKey(value);
            super(registry, key);
            this.__internal__outputType = getType(registry, value);
            this.setMeta(getMeta(value), override.section || section, override.method || method);
        }
        get args() {
            return this.__internal__args;
        }
        get meta() {
            return this.__internal__meta;
        }
        get method() {
            return this.__internal__method;
        }
        get outputType() {
            return this.__internal__outputType;
        }
        get section() {
            return this.__internal__section;
        }
        is(key) {
            return key.section === this.section && key.method === this.method;
        }
        setMeta(meta, section, method) {
            this.__internal__meta = meta;
            this.__internal__method = method || this.__internal__method;
            this.__internal__section = section || this.__internal__section;
            if (meta) {
                this.__internal__outputType = unwrapStorageType(this.registry, meta.type);
            }
            try {
                this.__internal__args = decodeArgsFromMeta(this.registry, this.toU8a(true), meta);
            }
            catch {
            }
            return this;
        }
        toHuman() {
            return this.__internal__args.length
                ? this.__internal__args.map((a) => a.toHuman())
                : super.toHuman();
        }
        toRawType() {
            return 'StorageKey';
        }
    }

    const baseTypes = /*#__PURE__*/Object.freeze({
        __proto__: null,
        BitVec: BitVec,
        Bool: bool,
        Bytes: Bytes,
        Data: Data,
        F32: f32,
        F64: f64,
        GenericAccountId: GenericAccountId,
        GenericAccountId32: GenericAccountId,
        GenericAccountId33: GenericAccountId33,
        GenericAccountIndex: GenericAccountIndex,
        GenericAddress: GenericMultiAddress,
        GenericBlock: GenericBlock,
        GenericCall: GenericCall,
        GenericChainProperties: GenericChainProperties,
        GenericConsensusEngineId: GenericConsensusEngineId,
        GenericEthereumAccountId: GenericEthereumAccountId,
        GenericEthereumLookupSource: GenericEthereumLookupSource,
        GenericEvent: GenericEvent,
        GenericEventData: GenericEventData,
        GenericExtrinsic: GenericExtrinsic,
        GenericExtrinsicEra: GenericExtrinsicEra,
        GenericExtrinsicPayload: GenericExtrinsicPayload,
        GenericExtrinsicPayloadUnknown: GenericExtrinsicPayloadUnknown,
        GenericExtrinsicPayloadV4: GenericExtrinsicPayloadV4,
        GenericExtrinsicSignatureV4: GenericExtrinsicSignatureV4,
        GenericExtrinsicUnknown: GenericExtrinsicUnknown,
        GenericExtrinsicV4: GenericExtrinsicV4,
        GenericImmortalEra: ImmortalEra,
        GenericLookupSource: GenericLookupSource,
        GenericMortalEra: MortalEra,
        GenericMultiAddress: GenericMultiAddress,
        GenericSignerPayload: GenericSignerPayload,
        GenericVote: GenericVote,
        I128: i128,
        I16: i16,
        I256: i256,
        I32: i32,
        I64: i64,
        I8: i8,
        ISize: isize,
        Null: Null,
        OptionBool: OptionBool,
        StorageKey: StorageKey,
        Text: Text,
        Type: Type,
        U128: u128,
        U16: u16,
        U256: u256,
        U32: u32,
        U64: u64,
        U8: u8,
        USize: usize,
        bool: bool,
        f32: f32,
        f64: f64,
        i128: i128,
        i16: i16,
        i256: i256,
        i32: i32,
        i64: i64,
        i8: i8,
        isize: isize,
        u128: u128,
        u16: u16,
        u256: u256,
        u32: u32,
        u64: u64,
        u8: u8,
        usize: usize
    });

    function convert(fn) {
        return ({ name }) => fn(name);
    }
    const objectNameToCamel =  convert(util.stringCamelCase);
    const objectNameToString =  convert((n) => n.toString());

    function isTx(tx, callIndex) {
        return tx.callIndex[0] === callIndex[0] && tx.callIndex[1] === callIndex[1];
    }
    function createUnchecked(registry, section, callIndex, callMetadata) {
        const expectedArgs = callMetadata.fields;
        const funcName = util.stringCamelCase(callMetadata.name);
        const extrinsicFn = (...args) => {
            if (expectedArgs.length !== args.length) {
                throw new Error(`Extrinsic ${section}.${funcName} expects ${expectedArgs.length} arguments, got ${args.length}.`);
            }
            return registry.createTypeUnsafe('Call', [{ args, callIndex }, callMetadata]);
        };
        extrinsicFn.is = (tx) => isTx(tx, callIndex);
        extrinsicFn.callIndex = callIndex;
        extrinsicFn.meta = callMetadata;
        extrinsicFn.method = funcName;
        extrinsicFn.section = section;
        extrinsicFn.toJSON = () => callMetadata.toJSON();
        return extrinsicFn;
    }

    function filterCallsSome({ calls }) {
        return calls.isSome;
    }
    function createCallFunction(registry, lookup, variant, sectionName, sectionIndex) {
        const { fields, index } = variant;
        const count = fields.length;
        const args = new Array(count);
        for (let i = 0; i < count; i++) {
            const { name, type, typeName } = fields[i];
            args[i] = util.objectSpread({
                name: util.stringCamelCase(name.unwrapOr(`param${i}`)),
                type: getSiName(lookup, type)
            }, typeName.isSome
                ? { typeName: typeName.unwrap() }
                : null);
        }
        return createUnchecked(registry, sectionName, new Uint8Array([sectionIndex, index.toNumber()]), registry.createTypeUnsafe('FunctionMetadataLatest', [util.objectSpread({ args }, variant)]));
    }
    function decorateExtrinsics(registry, { lookup, pallets }, version) {
        const result = {};
        const filtered = pallets.filter(filterCallsSome);
        for (let i = 0, count = filtered.length; i < count; i++) {
            const { calls, index, name } = filtered[i];
            const sectionName = util.stringCamelCase(name);
            const sectionIndex = version >= 12 ? index.toNumber() : i;
            util.lazyMethod(result, sectionName, () => lazyVariants(lookup, calls.unwrap(), objectNameToCamel, (variant) => createCallFunction(registry, lookup, variant, sectionName, sectionIndex)));
        }
        return result;
    }

    function createStorageHasher(registry, hasher) {
        if (hasher.toNumber() >= 2) {
            return registry.createTypeUnsafe('StorageHasherV10', [hasher.toNumber() + 1]);
        }
        return registry.createTypeUnsafe('StorageHasherV10', [hasher]);
    }
    function createStorageType(registry, entryType) {
        if (entryType.isMap) {
            return [util.objectSpread({}, entryType.asMap, {
                    hasher: createStorageHasher(registry, entryType.asMap.hasher)
                }), 1];
        }
        if (entryType.isDoubleMap) {
            return [util.objectSpread({}, entryType.asDoubleMap, {
                    hasher: createStorageHasher(registry, entryType.asDoubleMap.hasher),
                    key2Hasher: createStorageHasher(registry, entryType.asDoubleMap.key2Hasher)
                }), 2];
        }
        return [entryType.asPlain, 0];
    }
    function convertModule(registry, mod) {
        const storage = mod.storage.unwrapOr(null);
        return registry.createTypeUnsafe('ModuleMetadataV10', [util.objectSpread({}, mod, {
                storage: storage
                    ? util.objectSpread({}, storage, {
                        items: storage.items.map((item) => util.objectSpread({}, item, {
                            type: registry.createTypeUnsafe('StorageEntryTypeV10', createStorageType(registry, item.type))
                        }))
                    })
                    : null
            })]);
    }
    function toV10(registry, { modules }) {
        return registry.createTypeUnsafe('MetadataV10', [{
                modules: modules.map((mod) => convertModule(registry, mod))
            }]);
    }

    function toV11(registry, { modules }) {
        return registry.createTypeUnsafe('MetadataV11', [{
                extrinsic: {
                    signedExtensions: [],
                    version: 0
                },
                modules
            }]);
    }

    function toV12(registry, { extrinsic, modules }) {
        return registry.createTypeUnsafe('MetadataV12', [{
                extrinsic,
                modules: modules.map((mod) => registry.createTypeUnsafe('ModuleMetadataV12', [util.objectSpread({}, mod, { index: 255 })]))
            }]);
    }

    function toV13(registry, v12) {
        return registry.createTypeUnsafe('MetadataV13', [v12]);
    }

    const typesAlias = {
        assets: {
            Approval: 'AssetApproval',
            ApprovalKey: 'AssetApprovalKey',
            Balance: 'TAssetBalance',
            DestroyWitness: 'AssetDestroyWitness'
        },
        babe: {
            EquivocationProof: 'BabeEquivocationProof'
        },
        balances: {
            Status: 'BalanceStatus'
        },
        beefy: {
            AuthorityId: 'BeefyId'
        },
        contracts: {
            StorageKey: 'ContractStorageKey'
        },
        electionProviderMultiPhase: {
            Phase: 'ElectionPhase'
        },
        ethereum: {
            Block: 'EthBlock',
            Header: 'EthHeader',
            Receipt: 'EthReceipt',
            Transaction: 'EthTransaction',
            TransactionStatus: 'EthTransactionStatus'
        },
        evm: {
            Account: 'EvmAccount',
            Log: 'EvmLog',
            Vicinity: 'EvmVicinity'
        },
        grandpa: {
            Equivocation: 'GrandpaEquivocation',
            EquivocationProof: 'GrandpaEquivocationProof'
        },
        identity: {
            Judgement: 'IdentityJudgement'
        },
        inclusion: {
            ValidatorIndex: 'ParaValidatorIndex'
        },
        paraDisputes: {
            ValidatorIndex: 'ParaValidatorIndex'
        },
        paraInclusion: {
            ValidatorIndex: 'ParaValidatorIndex'
        },
        paraScheduler: {
            ValidatorIndex: 'ParaValidatorIndex'
        },
        paraShared: {
            ValidatorIndex: 'ParaValidatorIndex'
        },
        parachains: {
            Id: 'ParaId'
        },
        parasDisputes: {
            ValidatorIndex: 'ParaValidatorIndex'
        },
        parasInclusion: {
            ValidatorIndex: 'ParaValidatorIndex'
        },
        parasScheduler: {
            ValidatorIndex: 'ParaValidatorIndex'
        },
        parasShared: {
            ValidatorIndex: 'ParaValidatorIndex'
        },
        proposeParachain: {
            Proposal: 'ParachainProposal'
        },
        proxy: {
            Announcement: 'ProxyAnnouncement'
        },
        scheduler: {
            ValidatorIndex: 'ParaValidatorIndex'
        },
        shared: {
            ValidatorIndex: 'ParaValidatorIndex'
        },
        society: {
            Judgement: 'SocietyJudgement',
            Vote: 'SocietyVote'
        },
        staking: {
            Compact: 'CompactAssignments'
        },
        treasury: {
            Proposal: 'TreasuryProposal'
        },
        xcm: {
            AssetId: 'XcmAssetId'
        },
        xcmPallet: {
            AssetId: 'XcmAssetId'
        }
    };
    function getAliasTypes({ knownTypes }, section) {
        return {
            ...(typesAlias[section] ?? {}),
            ...(knownTypes.typesAlias?.[section] ?? {})
        };
    }

    const BOXES = [['<', '>'], ['<', ','], [',', '>'], ['(', ')'], ['(', ','], [',', ','], [',', ')']];
    function compatType(specs, _type) {
        const type = _type.toString();
        const index = specs.findIndex(({ def }) => def.HistoricMetaCompat === type);
        if (index !== -1) {
            return index;
        }
        return specs.push({
            def: {
                HistoricMetaCompat: type
            }
        }) - 1;
    }
    function compatTypes(specs, ...types) {
        for (let i = 0, count = types.length; i < count; i++) {
            compatType(specs, types[i]);
        }
    }
    function makeTupleType(specs, entries) {
        return specs.push({
            def: {
                Tuple: entries
            }
        }) - 1;
    }
    function makeVariantType(modName, variantType, specs, variants) {
        return specs.push({
            def: {
                Variant: { variants }
            },
            path: [`pallet_${modName.toString()}`, 'pallet', variantType]
        }) - 1;
    }
    function registerOriginCaller(registry, modules, metaVersion) {
        registry.register({
            OriginCaller: {
                _enum: modules
                    .map((mod, index) => [
                    mod.name.toString(),
                    metaVersion >= 12
                        ? mod.index.toNumber()
                        : index
                ])
                    .sort((a, b) => a[1] - b[1])
                    .reduce((result, [name, index]) => {
                    for (let i = Object.keys(result).length; i < index; i++) {
                        result[`Empty${i}`] = 'Null';
                    }
                    result[name] = knownOrigins[name] || 'Null';
                    return result;
                }, {})
            }
        });
    }
    function setTypeOverride(sectionTypes, types) {
        types.forEach((type) => {
            const override = Object.keys(sectionTypes).find((aliased) => type.eq(aliased));
            if (override) {
                type.setOverride(sectionTypes[override]);
            }
            else {
                const orig = type.toString();
                const alias = Object
                    .entries(sectionTypes)
                    .reduce((result, [src, dst]) => BOXES.reduce((result, [a, z]) => result.replace(`${a}${src}${z}`, `${a}${dst}${z}`), result), orig);
                if (orig !== alias) {
                    type.setOverride(alias);
                }
            }
        });
    }
    function convertCalls(specs, registry, modName, calls, sectionTypes) {
        const variants = calls.map(({ args, docs, name }, index) => {
            setTypeOverride(sectionTypes, args.map(({ type }) => type));
            return registry.createTypeUnsafe('SiVariant', [{
                    docs,
                    fields: args.map(({ name, type }) => registry.createTypeUnsafe('SiField', [{ name, type: compatType(specs, type) }])),
                    index,
                    name
                }]);
        });
        return registry.createTypeUnsafe('PalletCallMetadataV14', [{
                type: makeVariantType(modName, 'Call', specs, variants)
            }]);
    }
    function convertConstants(specs, registry, constants, sectionTypes) {
        return constants.map(({ docs, name, type, value }) => {
            setTypeOverride(sectionTypes, [type]);
            return registry.createTypeUnsafe('PalletConstantMetadataV14', [{
                    docs,
                    name,
                    type: compatType(specs, type),
                    value
                }]);
        });
    }
    function convertErrors(specs, registry, modName, errors, _sectionTypes) {
        const variants = errors.map(({ docs, name }, index) => registry.createTypeUnsafe('SiVariant', [{
                docs,
                fields: [],
                index,
                name
            }]));
        return registry.createTypeUnsafe('PalletErrorMetadataV14', [{
                type: makeVariantType(modName, 'Error', specs, variants)
            }]);
    }
    function convertEvents(specs, registry, modName, events, sectionTypes) {
        const variants = events.map(({ args, docs, name }, index) => {
            setTypeOverride(sectionTypes, args);
            return registry.createTypeUnsafe('SiVariant', [{
                    docs,
                    fields: args.map((t) => registry.createTypeUnsafe('SiField', [{ type: compatType(specs, t) }])),
                    index,
                    name
                }]);
        });
        return registry.createTypeUnsafe('PalletEventMetadataV14', [{
                type: makeVariantType(modName, 'Event', specs, variants)
            }]);
    }
    function createMapEntry(specs, registry, sectionTypes, { hashers, isLinked, isOptional, keys, value }) {
        setTypeOverride(sectionTypes, [value, ...(Array.isArray(keys) ? keys : [keys])]);
        return registry.createTypeUnsafe('StorageEntryTypeV14', [{
                Map: {
                    hashers,
                    key: hashers.length === 1
                        ? compatType(specs, keys[0])
                        : makeTupleType(specs, keys.map((t) => compatType(specs, t))),
                    value: isLinked
                        ? compatType(specs, `(${isOptional ? `Option<${value.toString()}>` : value.toString()}, Linkage<${keys[0].toString()}>)`)
                        : compatType(specs, value)
                }
            }]);
    }
    function convertStorage(specs, registry, { items, prefix }, sectionTypes) {
        return registry.createTypeUnsafe('PalletStorageMetadataV14', [{
                items: items.map(({ docs, fallback, modifier, name, type }) => {
                    let entryType;
                    if (type.isPlain) {
                        const plain = type.asPlain;
                        setTypeOverride(sectionTypes, [plain]);
                        entryType = registry.createTypeUnsafe('StorageEntryTypeV14', [{
                                Plain: compatType(specs, plain)
                            }]);
                    }
                    else if (type.isMap) {
                        const map = type.asMap;
                        entryType = createMapEntry(specs, registry, sectionTypes, {
                            hashers: [map.hasher],
                            isLinked: map.linked.isTrue,
                            isOptional: modifier.isOptional,
                            keys: [map.key],
                            value: map.value
                        });
                    }
                    else if (type.isDoubleMap) {
                        const dm = type.asDoubleMap;
                        entryType = createMapEntry(specs, registry, sectionTypes, {
                            hashers: [dm.hasher, dm.key2Hasher],
                            isLinked: false,
                            isOptional: modifier.isOptional,
                            keys: [dm.key1, dm.key2],
                            value: dm.value
                        });
                    }
                    else {
                        const nm = type.asNMap;
                        entryType = createMapEntry(specs, registry, sectionTypes, {
                            hashers: nm.hashers,
                            isLinked: false,
                            isOptional: modifier.isOptional,
                            keys: nm.keyVec,
                            value: nm.value
                        });
                    }
                    return registry.createTypeUnsafe('StorageEntryMetadataV14', [{
                            docs,
                            fallback,
                            modifier,
                            name,
                            type: entryType
                        }]);
                }),
                prefix
            }]);
    }
    function convertExtrinsic(registry, { signedExtensions, version }) {
        return registry.createTypeUnsafe('ExtrinsicMetadataV14', [{
                signedExtensions: signedExtensions.map((identifier) => ({
                    identifier,
                    type: 0
                })),
                type: 0,
                version
            }]);
    }
    function createPallet(specs, registry, mod, { calls, constants, errors, events, storage }) {
        const sectionTypes = getAliasTypes(registry, util.stringCamelCase(mod.name));
        return registry.createTypeUnsafe('PalletMetadataV14', [{
                calls: calls && convertCalls(specs, registry, mod.name, calls, sectionTypes),
                constants: convertConstants(specs, registry, constants, sectionTypes),
                errors: errors && convertErrors(specs, registry, mod.name, errors),
                events: events && convertEvents(specs, registry, mod.name, events, sectionTypes),
                index: mod.index,
                name: mod.name,
                storage: storage && convertStorage(specs, registry, storage, sectionTypes)
            }]);
    }
    function toV14(registry, v13, metaVersion) {
        const specs = [];
        compatTypes(specs, 'Null', 'u8', 'u16', 'u32', 'u64');
        registerOriginCaller(registry, v13.modules, metaVersion);
        const extrinsic = convertExtrinsic(registry, v13.extrinsic);
        const pallets = v13.modules.map((mod) => createPallet(specs, registry, mod, {
            calls: mod.calls.unwrapOr(null),
            constants: mod.constants,
            errors: mod.errors.length ? mod.errors : null,
            events: mod.events.unwrapOr(null),
            storage: mod.storage.unwrapOr(null)
        }));
        return registry.createTypeUnsafe('MetadataV14', [{
                extrinsic,
                lookup: {
                    types: specs.map((type, id) => registry.createTypeUnsafe('PortableType', [{ id, type }]))
                },
                pallets
            }]);
    }

    function toV15(registry, v14, _) {
        const unchecked = v14.lookup.paramTypes.SpRuntimeUncheckedExtrinsic;
        return registry.createTypeUnsafe('MetadataV15', [
            util.objectSpread({}, v14, {
                extrinsic: registry.createTypeUnsafe('ExtrinsicMetadataV15', [
                    util.objectSpread({}, v14.extrinsic, {
                        addressType: unchecked?.[0].type.unwrapOr(0),
                        callType: unchecked?.[1].type.unwrapOr(0),
                        extraType: unchecked?.[3].type.unwrapOr(0),
                        signatureType: unchecked?.[2].type.unwrapOr(0)
                    })
                ]),
                outerEnums: registry.createTypeUnsafe('OuterEnums15', [{
                        callType: unchecked?.[1].type.unwrapOr(0),
                        eventType: v14.lookup.paramTypes.FrameSystemEventRecord?.[0].type.unwrapOr(0)
                    }])
            })
        ]);
    }

    function toLatest(_registry, v15, _metaVersion) {
        return v15;
    }

    const MAGIC_NUMBER = 0x6174656d;
    class MagicNumber extends u32 {
        constructor(registry, value) {
            super(registry, value);
            if (!this.isEmpty && !this.eq(MAGIC_NUMBER)) {
                throw new Error(`MagicNumber mismatch: expected ${registry.createTypeUnsafe('u32', [MAGIC_NUMBER]).toHex()}, found ${this.toHex()}`);
            }
        }
    }

    const KNOWN_VERSIONS = [15, 14, 13, 12, 11, 10, 9];
    const LATEST_VERSION = KNOWN_VERSIONS[0];
    const TO_CALLS_VERSION = 14;

    class MetadataVersioned extends Struct {
        __internal__converted = new Map();
        constructor(registry, value) {
            super(registry, {
                magicNumber: MagicNumber,
                metadata: 'MetadataAll'
            }, value);
        }
        __internal__assertVersion = (version) => {
            if (this.version > version) {
                throw new Error(`Cannot convert metadata from version ${this.version} to ${version}`);
            }
            return this.version === version;
        };
        __internal__getVersion = (version, fromPrev) => {
            if (version !== 'latest' && this.__internal__assertVersion(version)) {
                const asCurr = `asV${version}`;
                return this.__internal__metadata()[asCurr];
            }
            if (!this.__internal__converted.has(version)) {
                const asPrev = version === 'latest'
                    ? `asV${LATEST_VERSION}`
                    : `asV${(version - 1)}`;
                this.__internal__converted.set(version, fromPrev(this.registry, this[asPrev], this.version));
            }
            return this.__internal__converted.get(version);
        };
        __internal__metadata = () => {
            return this.getT('metadata');
        };
        get asCallsOnly() {
            return new MetadataVersioned(this.registry, {
                magicNumber: this.magicNumber,
                metadata: this.registry.createTypeUnsafe('MetadataAll', [toCallsOnly(this.registry, this.asLatest), TO_CALLS_VERSION])
            });
        }
        get asV9() {
            this.__internal__assertVersion(9);
            return this.__internal__metadata().asV9;
        }
        get asV10() {
            return this.__internal__getVersion(10, toV10);
        }
        get asV11() {
            return this.__internal__getVersion(11, toV11);
        }
        get asV12() {
            return this.__internal__getVersion(12, toV12);
        }
        get asV13() {
            return this.__internal__getVersion(13, toV13);
        }
        get asV14() {
            return this.__internal__getVersion(14, toV14);
        }
        get asV15() {
            return this.__internal__getVersion(15, toV15);
        }
        get asLatest() {
            return this.__internal__getVersion('latest', toLatest);
        }
        get magicNumber() {
            return this.getT('magicNumber');
        }
        get version() {
            return this.__internal__metadata().index;
        }
        getUniqTypes(throwError) {
            return getUniqTypes(this.registry, this.asLatest, throwError);
        }
        toJSON() {
            this.asLatest;
            return super.toJSON();
        }
    }

    const EMPTY_METADATA = new Uint8Array([0x6d, 0x65, 0x74, 0x61, 9]);
    const VERSION_IDX = EMPTY_METADATA.length - 1;
    function decodeU8a(registry, u8a) {
        if (u8a.length === 0) {
            return EMPTY_METADATA;
        }
        else if (u8a[VERSION_IDX] === 9) {
            try {
                return new MetadataVersioned(registry, u8a);
            }
            catch {
                u8a[VERSION_IDX] = 10;
            }
        }
        return u8a;
    }
    class Metadata extends MetadataVersioned {
        constructor(registry, value) {
            super(registry, util.isU8a(value) || util.isString(value)
                ? decodeU8a(registry, util.u8aToU8a(value))
                : value);
        }
    }

    function decorateConstants(registry, { pallets }, _version) {
        const result = {};
        for (let i = 0, count = pallets.length; i < count; i++) {
            const { constants, name } = pallets[i];
            if (!constants.isEmpty) {
                util.lazyMethod(result, util.stringCamelCase(name), () => util.lazyMethods({}, constants, (constant) => {
                    const codec = registry.createTypeUnsafe(registry.createLookupType(constant.type), [util.hexToU8a(constant.value.toHex())]);
                    codec.meta = constant;
                    return codec;
                }, objectNameToCamel));
            }
        }
        return result;
    }

    function variantToMeta(lookup, variant) {
        return util.objectSpread({ args: variant.fields.map(({ type }) => lookup.getTypeDef(type).type) }, variant);
    }
    function decorateErrors(registry, { lookup, pallets }, version) {
        const result = {};
        for (let i = 0, count = pallets.length; i < count; i++) {
            const { errors, index, name } = pallets[i];
            if (errors.isSome) {
                const sectionIndex = version >= 12 ? index.toNumber() : i;
                util.lazyMethod(result, util.stringCamelCase(name), () => lazyVariants(lookup, errors.unwrap(), objectNameToString, (variant) => ({
                    is: (errorMod) => util.isCodec(errorMod) &&
                        util.isCodec(errorMod.index) &&
                        errorMod.index.eq(sectionIndex) && (util.isU8a(errorMod.error)
                        ? errorMod.error[0] === variant.index.toNumber()
                        : util.isCodec(errorMod.error) && errorMod.error.eq(variant.index)),
                    meta: registry.createTypeUnsafe('ErrorMetadataLatest', [variantToMeta(lookup, variant)])
                })));
            }
        }
        return result;
    }

    function filterEventsSome({ events }) {
        return events.isSome;
    }
    function decorateEvents(registry, { lookup, pallets }, version) {
        const result = {};
        const filtered = pallets.filter(filterEventsSome);
        for (let i = 0, count = filtered.length; i < count; i++) {
            const { events, index, name } = filtered[i];
            const sectionIndex = version >= 12 ? index.toNumber() : i;
            util.lazyMethod(result, util.stringCamelCase(name), () => lazyVariants(lookup, events.unwrap(), objectNameToString, (variant) => ({
                is: (eventRecord) => util.isCodec(eventRecord) &&
                    util.isU8a(eventRecord.index) &&
                    sectionIndex === eventRecord.index[0] &&
                    variant.index.eq(eventRecord.index[1]),
                meta: registry.createTypeUnsafe('EventMetadataLatest', [variantToMeta(lookup, variant)])
            })));
        }
        return result;
    }

    const DEFAULT_FN = (data) => utilCrypto.xxhashAsU8a(data, 128);
    const HASHERS = {
        Blake2_128: (data) =>
         utilCrypto.blake2AsU8a(data, 128),
        Blake2_128Concat: (data) =>
         util.u8aConcat(utilCrypto.blake2AsU8a(data, 128), util.u8aToU8a(data)),
        Blake2_256: (data) =>
         utilCrypto.blake2AsU8a(data, 256),
        Identity: (data) => util.u8aToU8a(data),
        Twox128: (data) => utilCrypto.xxhashAsU8a(data, 128),
        Twox256: (data) => utilCrypto.xxhashAsU8a(data, 256),
        Twox64Concat: (data) => util.u8aConcat(utilCrypto.xxhashAsU8a(data, 64), util.u8aToU8a(data))
    };
    function getHasher(hasher) {
        return HASHERS[hasher.type] || DEFAULT_FN;
    }

    const NO_RAW_ARGS = {
        args: [],
        hashers: [],
        keys: []
    };
    function filterDefined(a) {
        return !util.isUndefined(a);
    }
    function assertArgs({ method, section }, { args, keys }) {
        if (!Array.isArray(args)) {
            throw new Error(`Call to ${util.stringCamelCase(section || 'unknown')}.${util.stringCamelCase(method || 'unknown')} needs ${keys.length} arguments`);
        }
        else if (args.filter(filterDefined).length !== keys.length) {
            throw new Error(`Call to ${util.stringCamelCase(section || 'unknown')}.${util.stringCamelCase(method || 'unknown')} needs ${keys.length} arguments, found [${args.join(', ')}]`);
        }
    }
    function createKeyRawParts(registry, itemFn, { args, hashers, keys }) {
        const count = keys.length;
        const extra = new Array(count);
        for (let i = 0; i < count; i++) {
            extra[i] = getHasher(hashers[i])(registry.createTypeUnsafe(registry.createLookupType(keys[i]), [args[i]]).toU8a());
        }
        return [
            [
                utilCrypto.xxhashAsU8a(itemFn.prefix, 128),
                utilCrypto.xxhashAsU8a(itemFn.method, 128)
            ],
            extra
        ];
    }
    function createKeyInspect(registry, itemFn, args) {
        assertArgs(itemFn, args);
        const { meta } = itemFn;
        const [prefix, extra] = createKeyRawParts(registry, itemFn, args);
        let types = [];
        if (meta.type.isMap) {
            const { hashers, key } = meta.type.asMap;
            types = hashers.length === 1
                ? [`${hashers[0].type}(${getSiName(registry.lookup, key)})`]
                : registry.lookup.getSiType(key).def.asTuple.map((k, i) => `${hashers[i].type}(${getSiName(registry.lookup, k)})`);
        }
        const names = ['module', 'method'].concat(...args.args.map((_, i) => types[i]));
        return {
            inner: prefix
                .concat(...extra)
                .map((v, i) => ({ name: names[i], outer: [v] }))
        };
    }
    function createKeyRaw(registry, itemFn, args) {
        const [prefix, extra] = createKeyRawParts(registry, itemFn, args);
        return util.u8aConcat(...prefix, ...extra);
    }
    function createKey(registry, itemFn, args) {
        assertArgs(itemFn, args);
        return util.compactAddLength(createKeyRaw(registry, itemFn, args));
    }
    function createStorageInspect(registry, itemFn, options) {
        const { meta: { type } } = itemFn;
        return (...args) => {
            if (type.isPlain) {
                return options.skipHashing
                    ? { inner: [], name: 'wellKnown', outer: [util.u8aToU8a(options.key)] }
                    : createKeyInspect(registry, itemFn, NO_RAW_ARGS);
            }
            const { hashers, key } = type.asMap;
            return hashers.length === 1
                ? createKeyInspect(registry, itemFn, { args, hashers, keys: [key] })
                : createKeyInspect(registry, itemFn, { args, hashers, keys: registry.lookup.getSiType(key).def.asTuple });
        };
    }
    function createStorageFn(registry, itemFn, options) {
        const { meta: { type } } = itemFn;
        let cacheKey = null;
        return (...args) => {
            if (type.isPlain) {
                if (!cacheKey) {
                    cacheKey = options.skipHashing
                        ? util.compactAddLength(util.u8aToU8a(options.key))
                        : createKey(registry, itemFn, NO_RAW_ARGS);
                }
                return cacheKey;
            }
            const { hashers, key } = type.asMap;
            return hashers.length === 1
                ? createKey(registry, itemFn, { args, hashers, keys: [key] })
                : createKey(registry, itemFn, { args, hashers, keys: registry.lookup.getSiType(key).def.asTuple });
        };
    }
    function createWithMeta(registry, itemFn, options) {
        const { meta, method, prefix, section } = itemFn;
        const storageFn = createStorageFn(registry, itemFn, options);
        storageFn.inspect = createStorageInspect(registry, itemFn, options);
        storageFn.meta = meta;
        storageFn.method = util.stringCamelCase(method);
        storageFn.prefix = prefix;
        storageFn.section = section;
        storageFn.toJSON = () => util.objectSpread({ storage: { method, prefix, section } }, meta.toJSON());
        return storageFn;
    }
    function extendHeadMeta(registry, { meta: { docs, name, type }, section }, { method }, iterFn) {
        const meta = registry.createTypeUnsafe('StorageEntryMetadataLatest', [{
                docs,
                fallback: registry.createTypeUnsafe('Bytes', []),
                modifier: registry.createTypeUnsafe('StorageEntryModifierLatest', [1]),
                name,
                type: registry.createTypeUnsafe('StorageEntryTypeLatest', [type.asMap.key, 0])
            }]);
        iterFn.meta = meta;
        const fn = (...args) => registry.createTypeUnsafe('StorageKey', [iterFn(...args), { method, section }]);
        fn.meta = meta;
        return fn;
    }
    function extendPrefixedMap(registry, itemFn, storageFn) {
        const { meta: { type }, method, section } = itemFn;
        storageFn.iterKey = extendHeadMeta(registry, itemFn, storageFn, (...args) => {
            if (args.length && (type.isPlain || (args.length >= type.asMap.hashers.length))) {
                throw new Error(`Iteration of ${util.stringCamelCase(section || 'unknown')}.${util.stringCamelCase(method || 'unknown')} needs arguments to be at least one less than the full arguments, found [${args.join(', ')}]`);
            }
            if (args.length) {
                if (type.isMap) {
                    const { hashers, key } = type.asMap;
                    const keysVec = hashers.length === 1
                        ? [key]
                        : registry.lookup.getSiType(key).def.asTuple;
                    return new Raw(registry, createKeyRaw(registry, itemFn, { args, hashers: hashers.slice(0, args.length), keys: keysVec.slice(0, args.length) }));
                }
            }
            return new Raw(registry, createKeyRaw(registry, itemFn, NO_RAW_ARGS));
        });
        return storageFn;
    }
    function createFunction(registry, itemFn, options) {
        const { meta: { type } } = itemFn;
        const storageFn = createWithMeta(registry, itemFn, options);
        if (type.isMap) {
            extendPrefixedMap(registry, itemFn, storageFn);
        }
        storageFn.keyPrefix = (...args) => (storageFn.iterKey && storageFn.iterKey(...args)) ||
            util.compactStripLength(storageFn())[1];
        return storageFn;
    }

    function findSiPrimitive(registry, _prim) {
        const prim = _prim.toLowerCase();
        return registry.lookup.types.find((t) => (t.type.def.isPrimitive &&
            t.type.def.asPrimitive.toString().toLowerCase() === prim) || (t.type.def.isHistoricMetaCompat &&
            t.type.def.asHistoricMetaCompat.toString().toLowerCase() === prim));
    }
    function findSiType(registry, orig) {
        let portable = findSiPrimitive(registry, orig);
        if (!portable && orig === 'Bytes') {
            const u8 = findSiPrimitive(registry, 'u8');
            if (u8) {
                portable = registry.lookup.types.find((t) => (t.type.def.isSequence &&
                    t.type.def.asSequence.type.eq(u8.id)) || (t.type.def.isHistoricMetaCompat &&
                    t.type.def.asHistoricMetaCompat.eq(orig)));
            }
        }
        if (!portable) {
            console.warn(`Unable to map ${orig} to a lookup index`);
        }
        return portable;
    }
    function createRuntimeFunction({ method, prefix, section }, key, { docs, type }) {
        return (registry) => createFunction(registry, {
            meta: registry.createTypeUnsafe('StorageEntryMetadataLatest', [{
                    docs: registry.createTypeUnsafe('Vec<Text>', [[docs]]),
                    modifier: registry.createTypeUnsafe('StorageEntryModifierLatest', ['Required']),
                    name: registry.createTypeUnsafe('Text', [method]),
                    toJSON: () => key,
                    type: registry.createTypeUnsafe('StorageEntryTypeLatest', [{ Plain: findSiType(registry, type)?.id || 0 }])
                }]),
            method,
            prefix,
            section
        }, { key, skipHashing: true });
    }

    const prefix = 'Substrate';
    const section = 'substrate';
    function createSubstrateFn(method, key, meta) {
        return createRuntimeFunction({ method, prefix, section }, key, meta);
    }
    const substrate = {
        changesTrieConfig: createSubstrateFn('changesTrieConfig', ':changes_trie', {
            docs: 'Changes trie configuration is stored under this key.',
            type: 'u32'
        }),
        childStorageKeyPrefix: createSubstrateFn('childStorageKeyPrefix', ':child_storage:', {
            docs: 'Prefix of child storage keys.',
            type: 'u32'
        }),
        code: createSubstrateFn('code', ':code', {
            docs: 'Wasm code of the runtime.',
            type: 'Bytes'
        }),
        extrinsicIndex: createSubstrateFn('extrinsicIndex', ':extrinsic_index', {
            docs: 'Current extrinsic index (u32) is stored under this key.',
            type: 'u32'
        }),
        heapPages: createSubstrateFn('heapPages', ':heappages', {
            docs: 'Number of wasm linear memory pages required for execution of the runtime.',
            type: 'u64'
        }),
        intrablockEntropy: createSubstrateFn('intrablockEntropy', ':intrablock_entropy', {
            docs: 'Current intra-block entropy (a universally unique `[u8; 32]` value) is stored here.',
            type: '[u8; 32]'
        })
    };

    function getStorage(registry) {
        const storage = {};
        const entries = Object.entries(substrate);
        for (let e = 0, count = entries.length; e < count; e++) {
            storage[entries[e][0]] = entries[e][1](registry);
        }
        return { substrate: storage };
    }

    const VERSION_NAME = 'palletVersion';
    const VERSION_KEY = ':__STORAGE_VERSION__:';
    const VERSION_DOCS = { docs: 'Returns the current pallet version from storage', type: 'u16' };
    function decorateStorage(registry, { pallets }, _metaVersion) {
        const result = getStorage(registry);
        for (let i = 0, count = pallets.length; i < count; i++) {
            const { name, storage } = pallets[i];
            if (storage.isSome) {
                const section = util.stringCamelCase(name);
                const { items, prefix: _prefix } = storage.unwrap();
                const prefix = _prefix.toString();
                util.lazyMethod(result, section, () => util.lazyMethods({
                    palletVersion: createRuntimeFunction({ method: VERSION_NAME, prefix, section }, createKeyRaw(registry, { method: VERSION_KEY, prefix: name.toString() }, NO_RAW_ARGS), VERSION_DOCS)(registry)
                }, items, (meta) => createFunction(registry, { meta, method: meta.name.toString(), prefix, section }, {}), objectNameToCamel));
            }
        }
        return result;
    }

    function expandMetadata(registry, metadata) {
        if (!(metadata instanceof Metadata)) {
            throw new Error('You need to pass a valid Metadata instance to Decorated');
        }
        const latest = metadata.asLatest;
        const version = metadata.version;
        return {
            consts: decorateConstants(registry, latest),
            errors: decorateErrors(registry, latest, version),
            events: decorateEvents(registry, latest, version),
            query: decorateStorage(registry, latest),
            registry,
            tx: decorateExtrinsics(registry, latest, version)
        };
    }

    const DEFAULT_FIRST_CALL_IDX = new Uint8Array(2);
    const l = util.logger('registry');
    function sortDecimalStrings(a, b) {
        return parseInt(a, 10) - parseInt(b, 10);
    }
    function valueToString(v) {
        return v.toString();
    }
    function getFieldArgs(lookup, fields) {
        const count = fields.length;
        const args = new Array(count);
        for (let i = 0; i < count; i++) {
            args[i] = lookup.getTypeDef(fields[i].type).type;
        }
        return args;
    }
    function clearRecord(record) {
        const keys = Object.keys(record);
        for (let i = 0, count = keys.length; i < count; i++) {
            delete record[keys[i]];
        }
    }
    function getVariantStringIdx({ index }) {
        return index.toString();
    }
    function injectErrors(_, { lookup, pallets }, version, result) {
        clearRecord(result);
        for (let i = 0, count = pallets.length; i < count; i++) {
            const { errors, index, name } = pallets[i];
            if (errors.isSome) {
                const sectionName = util.stringCamelCase(name);
                util.lazyMethod(result, version >= 12 ? index.toNumber() : i, () => lazyVariants(lookup, errors.unwrap(), getVariantStringIdx, ({ docs, fields, index, name }) => ({
                    args: getFieldArgs(lookup, fields),
                    docs: docs.map(valueToString),
                    fields,
                    index: index.toNumber(),
                    method: name.toString(),
                    name: name.toString(),
                    section: sectionName
                })));
            }
        }
    }
    function injectEvents(registry, { lookup, pallets }, version, result) {
        const filtered = pallets.filter(filterEventsSome);
        clearRecord(result);
        for (let i = 0, count = filtered.length; i < count; i++) {
            const { events, index, name } = filtered[i];
            util.lazyMethod(result, version >= 12 ? index.toNumber() : i, () => lazyVariants(lookup, events.unwrap(), getVariantStringIdx, (variant) => {
                const meta = registry.createType('EventMetadataLatest', util.objectSpread({}, variant, { args: getFieldArgs(lookup, variant.fields) }));
                return class extends GenericEventData {
                    constructor(registry, value) {
                        super(registry, value, meta, util.stringCamelCase(name), variant.name.toString());
                    }
                };
            }));
        }
    }
    function injectExtrinsics(registry, { lookup, pallets }, version, result, mapping) {
        const filtered = pallets.filter(filterCallsSome);
        clearRecord(result);
        clearRecord(mapping);
        for (let i = 0, count = filtered.length; i < count; i++) {
            const { calls, index, name } = filtered[i];
            const sectionIndex = version >= 12 ? index.toNumber() : i;
            const sectionName = util.stringCamelCase(name);
            const allCalls = calls.unwrap();
            util.lazyMethod(result, sectionIndex, () => lazyVariants(lookup, allCalls, getVariantStringIdx, (variant) => createCallFunction(registry, lookup, variant, sectionName, sectionIndex)));
            const { path } = registry.lookup.getSiType(allCalls.type);
            const palletIdx = path.findIndex((v) => v.eq('pallet'));
            if (palletIdx !== -1) {
                const name = util.stringCamelCase(path
                    .slice(0, palletIdx)
                    .map((p, i) => i === 0
                    ? p.replace(/^(frame|pallet)_/, '')
                    : p)
                    .join(' '));
                if (!mapping[name]) {
                    mapping[name] = [sectionName];
                }
                else {
                    mapping[name].push(sectionName);
                }
            }
        }
    }
    function extractProperties(registry, metadata) {
        const original = registry.getChainProperties();
        const constants = decorateConstants(registry, metadata.asLatest, metadata.version);
        const ss58Format = constants['system'] && (constants['system']['sS58Prefix'] || constants['system']['ss58Prefix']);
        if (!ss58Format) {
            return original;
        }
        const { isEthereum, tokenDecimals, tokenSymbol } = original || {};
        return registry.createTypeUnsafe('ChainProperties', [{ isEthereum, ss58Format, tokenDecimals, tokenSymbol }]);
    }
    class TypeRegistry {
        __internal__chainProperties;
        __internal__classes = new Map();
        __internal__definitions = new Map();
        __internal__firstCallIndex = null;
        __internal__hasher = utilCrypto.blake2AsU8a;
        __internal__knownTypes = {};
        __internal__lookup;
        __internal__metadata;
        __internal__metadataVersion = 0;
        __internal__signedExtensions = fallbackExtensions;
        __internal__unknownTypes = new Map();
        __internal__userExtensions;
        __internal__knownDefaults;
        __internal__knownDefaultsEntries;
        __internal__knownDefinitions;
        __internal__metadataCalls = {};
        __internal__metadataErrors = {};
        __internal__metadataEvents = {};
        __internal__moduleMap = {};
        createdAtHash;
        constructor(createdAtHash) {
            this.__internal__knownDefaults = util.objectSpread({ Json, Metadata, PortableRegistry, Raw }, baseTypes);
            this.__internal__knownDefaultsEntries = Object.entries(this.__internal__knownDefaults);
            this.__internal__knownDefinitions = definitions;
            const allKnown = Object.values(this.__internal__knownDefinitions);
            for (let i = 0, count = allKnown.length; i < count; i++) {
                this.register(allKnown[i].types);
            }
            if (createdAtHash) {
                this.createdAtHash = this.createType('BlockHash', createdAtHash);
            }
        }
        get chainDecimals() {
            if (this.__internal__chainProperties?.tokenDecimals.isSome) {
                const allDecimals = this.__internal__chainProperties.tokenDecimals.unwrap();
                if (allDecimals.length) {
                    return allDecimals.map((b) => b.toNumber());
                }
            }
            return [12];
        }
        get chainIsEthereum() {
            return this.__internal__chainProperties?.isEthereum.isTrue || false;
        }
        get chainSS58() {
            return this.__internal__chainProperties?.ss58Format.isSome
                ? this.__internal__chainProperties.ss58Format.unwrap().toNumber()
                : undefined;
        }
        get chainTokens() {
            if (this.__internal__chainProperties?.tokenSymbol.isSome) {
                const allTokens = this.__internal__chainProperties.tokenSymbol.unwrap();
                if (allTokens.length) {
                    return allTokens.map(valueToString);
                }
            }
            return [util.formatBalance.getDefaults().unit];
        }
        get firstCallIndex() {
            return this.__internal__firstCallIndex || DEFAULT_FIRST_CALL_IDX;
        }
        isLookupType(value) {
            return /Lookup\d+$/.test(value);
        }
        createLookupType(lookupId) {
            return `Lookup${typeof lookupId === 'number' ? lookupId : lookupId.toNumber()}`;
        }
        get knownTypes() {
            return this.__internal__knownTypes;
        }
        get lookup() {
            return util.assertReturn(this.__internal__lookup, 'PortableRegistry has not been set on this registry');
        }
        get metadata() {
            return util.assertReturn(this.__internal__metadata, 'Metadata has not been set on this registry');
        }
        get unknownTypes() {
            return [...this.__internal__unknownTypes.keys()];
        }
        get signedExtensions() {
            return this.__internal__signedExtensions;
        }
        clearCache() {
            this.__internal__classes = new Map();
        }
        createClass(type) {
            return createClassUnsafe(this, type);
        }
        createClassUnsafe(type) {
            return createClassUnsafe(this, type);
        }
        createType(type, ...params) {
            return createTypeUnsafe(this, type, params);
        }
        createTypeUnsafe(type, params, options) {
            return createTypeUnsafe(this, type, params, options);
        }
        findMetaCall(callIndex) {
            const [section, method] = [callIndex[0], callIndex[1]];
            return util.assertReturn(this.__internal__metadataCalls[`${section}`] && this.__internal__metadataCalls[`${section}`][`${method}`], () => `findMetaCall: Unable to find Call with index [${section}, ${method}]/[${callIndex.toString()}]`);
        }
        findMetaError(errorIndex) {
            const [section, method] = util.isU8a(errorIndex)
                ? [errorIndex[0], errorIndex[1]]
                : [
                    errorIndex.index.toNumber(),
                    util.isU8a(errorIndex.error)
                        ? errorIndex.error[0]
                        : errorIndex.error.toNumber()
                ];
            return util.assertReturn(this.__internal__metadataErrors[`${section}`] && this.__internal__metadataErrors[`${section}`][`${method}`], () => `findMetaError: Unable to find Error with index [${section}, ${method}]/[${errorIndex.toString()}]`);
        }
        findMetaEvent(eventIndex) {
            const [section, method] = [eventIndex[0], eventIndex[1]];
            return util.assertReturn(this.__internal__metadataEvents[`${section}`] && this.__internal__metadataEvents[`${section}`][`${method}`], () => `findMetaEvent: Unable to find Event with index [${section}, ${method}]/[${eventIndex.toString()}]`);
        }
        get(name, withUnknown, knownTypeDef) {
            return this.getUnsafe(name, withUnknown, knownTypeDef);
        }
        getUnsafe(name, withUnknown, knownTypeDef) {
            let Type = this.__internal__classes.get(name) || this.__internal__knownDefaults[name];
            if (!Type) {
                const definition = this.__internal__definitions.get(name);
                let BaseType;
                if (definition) {
                    BaseType = createClassUnsafe(this, definition);
                }
                else if (knownTypeDef) {
                    BaseType = constructTypeClass(this, knownTypeDef);
                }
                else if (withUnknown) {
                    l.warn(`Unable to resolve type ${name}, it will fail on construction`);
                    this.__internal__unknownTypes.set(name, true);
                    BaseType = DoNotConstruct.with(name);
                }
                if (BaseType) {
                    Type = class extends BaseType {
                    };
                    this.__internal__classes.set(name, Type);
                    if (knownTypeDef && util.isNumber(knownTypeDef.lookupIndex)) {
                        this.__internal__classes.set(this.createLookupType(knownTypeDef.lookupIndex), Type);
                    }
                }
            }
            return Type;
        }
        getChainProperties() {
            return this.__internal__chainProperties;
        }
        getClassName(Type) {
            const names = [];
            for (const [name, Clazz] of this.__internal__knownDefaultsEntries) {
                if (Type === Clazz) {
                    names.push(name);
                }
            }
            for (const [name, Clazz] of this.__internal__classes.entries()) {
                if (Type === Clazz) {
                    names.push(name);
                }
            }
            return names.length
                ? names.sort().reverse()[0]
                : undefined;
        }
        getDefinition(typeName) {
            return this.__internal__definitions.get(typeName);
        }
        getModuleInstances(specName, moduleName) {
            return this.__internal__knownTypes?.typesBundle?.spec?.[specName.toString()]?.instances?.[moduleName] || this.__internal__moduleMap[moduleName];
        }
        getOrThrow(name) {
            const Clazz = this.get(name);
            if (!Clazz) {
                throw new Error(`type ${name} not found`);
            }
            return Clazz;
        }
        getOrUnknown(name) {
            return this.get(name, true);
        }
        getSignedExtensionExtra() {
            return expandExtensionTypes(this.__internal__signedExtensions, 'payload', this.__internal__userExtensions);
        }
        getSignedExtensionTypes() {
            return expandExtensionTypes(this.__internal__signedExtensions, 'extrinsic', this.__internal__userExtensions);
        }
        hasClass(name) {
            return this.__internal__classes.has(name) || !!this.__internal__knownDefaults[name];
        }
        hasDef(name) {
            return this.__internal__definitions.has(name);
        }
        hasType(name) {
            return !this.__internal__unknownTypes.get(name) && (this.hasClass(name) || this.hasDef(name));
        }
        hash(data) {
            return this.createType('CodecHash', this.__internal__hasher(data));
        }
        register(arg1, arg2) {
            if (util.isFunction(arg1)) {
                this.__internal__classes.set(arg1.name, arg1);
            }
            else if (util.isString(arg1)) {
                if (!util.isFunction(arg2)) {
                    throw new Error(`Expected class definition passed to '${arg1}' registration`);
                }
                else if (arg1 === arg2.toString()) {
                    throw new Error(`Unable to register circular ${arg1} === ${arg1}`);
                }
                this.__internal__classes.set(arg1, arg2);
            }
            else {
                this.__internal__registerObject(arg1);
            }
        }
        __internal__registerObject = (obj) => {
            const entries = Object.entries(obj);
            for (let e = 0, count = entries.length; e < count; e++) {
                const [name, type] = entries[e];
                if (util.isFunction(type)) {
                    this.__internal__classes.set(name, type);
                }
                else {
                    const def = util.isString(type)
                        ? type
                        : util.stringify(type);
                    if (name === def) {
                        throw new Error(`Unable to register circular ${name} === ${def}`);
                    }
                    if (this.__internal__classes.has(name)) {
                        this.__internal__classes.delete(name);
                    }
                    this.__internal__definitions.set(name, def);
                }
            }
        };
        setChainProperties(properties) {
            if (properties) {
                this.__internal__chainProperties = properties;
            }
        }
        setHasher(hasher) {
            this.__internal__hasher = hasher || utilCrypto.blake2AsU8a;
        }
        setKnownTypes(knownTypes) {
            this.__internal__knownTypes = knownTypes;
        }
        setLookup(lookup) {
            this.__internal__lookup = lookup;
            lookup.register();
        }
        __internal__registerLookup = (lookup) => {
            this.setLookup(lookup);
            let Weight = null;
            if (this.hasType('SpWeightsWeightV2Weight')) {
                const weightv2 = this.createType('SpWeightsWeightV2Weight');
                Weight = weightv2.refTime && weightv2.proofSize
                    ? 'SpWeightsWeightV2Weight'
                    : 'WeightV1';
            }
            else if (!util.isBn(this.createType('Weight'))) {
                Weight = 'WeightV1';
            }
            if (Weight) {
                this.register({ Weight });
            }
        };
        setMetadata(metadata, signedExtensions, userExtensions, noInitWarn) {
            this.__internal__metadata = metadata.asLatest;
            this.__internal__metadataVersion = metadata.version;
            this.__internal__firstCallIndex = null;
            this.__internal__registerLookup(this.__internal__metadata.lookup);
            injectExtrinsics(this, this.__internal__metadata, this.__internal__metadataVersion, this.__internal__metadataCalls, this.__internal__moduleMap);
            injectErrors(this, this.__internal__metadata, this.__internal__metadataVersion, this.__internal__metadataErrors);
            injectEvents(this, this.__internal__metadata, this.__internal__metadataVersion, this.__internal__metadataEvents);
            const [defSection] = Object
                .keys(this.__internal__metadataCalls)
                .sort(sortDecimalStrings);
            if (defSection) {
                const [defMethod] = Object
                    .keys(this.__internal__metadataCalls[defSection])
                    .sort(sortDecimalStrings);
                if (defMethod) {
                    this.__internal__firstCallIndex = new Uint8Array([parseInt(defSection, 10), parseInt(defMethod, 10)]);
                }
            }
            this.setSignedExtensions(signedExtensions || (this.__internal__metadata.extrinsic.version.gt(util.BN_ZERO)
                ? this.__internal__metadata.extrinsic.signedExtensions.map(({ identifier }) => identifier.toString())
                : fallbackExtensions), userExtensions, noInitWarn);
            this.setChainProperties(extractProperties(this, metadata));
        }
        setSignedExtensions(signedExtensions = fallbackExtensions, userExtensions, noInitWarn) {
            this.__internal__signedExtensions = signedExtensions;
            this.__internal__userExtensions = userExtensions;
            if (!noInitWarn) {
                const unknown = findUnknownExtensions(this.__internal__signedExtensions, this.__internal__userExtensions);
                if (unknown.length) {
                    l.warn(`Unknown signed extensions ${unknown.join(', ')} found, treating them as no-effect`);
                }
            }
        }
    }

    exports.BTreeMap = BTreeMap;
    exports.BTreeSet = BTreeSet;
    exports.BitVec = BitVec;
    exports.Bool = bool;
    exports.Bytes = Bytes;
    exports.CodecMap = CodecMap;
    exports.CodecSet = CodecSet;
    exports.Compact = Compact;
    exports.Data = Data;
    exports.DoNotConstruct = DoNotConstruct;
    exports.Enum = Enum;
    exports.F32 = f32;
    exports.F64 = f64;
    exports.GenericAccountId = GenericAccountId;
    exports.GenericAccountId32 = GenericAccountId;
    exports.GenericAccountId33 = GenericAccountId33;
    exports.GenericAccountIndex = GenericAccountIndex;
    exports.GenericAddress = GenericMultiAddress;
    exports.GenericBlock = GenericBlock;
    exports.GenericCall = GenericCall;
    exports.GenericChainProperties = GenericChainProperties;
    exports.GenericConsensusEngineId = GenericConsensusEngineId;
    exports.GenericEthereumAccountId = GenericEthereumAccountId;
    exports.GenericEthereumLookupSource = GenericEthereumLookupSource;
    exports.GenericEvent = GenericEvent;
    exports.GenericEventData = GenericEventData;
    exports.GenericExtrinsic = GenericExtrinsic;
    exports.GenericExtrinsicEra = GenericExtrinsicEra;
    exports.GenericExtrinsicPayload = GenericExtrinsicPayload;
    exports.GenericExtrinsicPayloadUnknown = GenericExtrinsicPayloadUnknown;
    exports.GenericExtrinsicPayloadV4 = GenericExtrinsicPayloadV4;
    exports.GenericExtrinsicSignatureV4 = GenericExtrinsicSignatureV4;
    exports.GenericExtrinsicUnknown = GenericExtrinsicUnknown;
    exports.GenericExtrinsicV4 = GenericExtrinsicV4;
    exports.GenericImmortalEra = ImmortalEra;
    exports.GenericLookupSource = GenericLookupSource;
    exports.GenericMortalEra = MortalEra;
    exports.GenericMultiAddress = GenericMultiAddress;
    exports.GenericSignerPayload = GenericSignerPayload;
    exports.GenericVote = GenericVote;
    exports.HashMap = HashMap;
    exports.I128 = i128;
    exports.I16 = i16;
    exports.I256 = i256;
    exports.I32 = i32;
    exports.I64 = i64;
    exports.I8 = i8;
    exports.ISize = isize;
    exports.Int = Int;
    exports.Json = Json;
    exports.Linkage = Linkage;
    exports.Map = CodecMap;
    exports.Metadata = Metadata;
    exports.Null = Null;
    exports.Option = Option;
    exports.OptionBool = OptionBool;
    exports.PortableRegistry = PortableRegistry;
    exports.Range = Range;
    exports.RangeInclusive = RangeInclusive;
    exports.Raw = Raw;
    exports.Result = Result;
    exports.Set = CodecSet;
    exports.StorageKey = StorageKey;
    exports.Struct = Struct;
    exports.Text = Text;
    exports.Tuple = Tuple;
    exports.Type = Type;
    exports.TypeRegistry = TypeRegistry;
    exports.U128 = u128;
    exports.U16 = u16;
    exports.U256 = u256;
    exports.U32 = u32;
    exports.U64 = u64;
    exports.U8 = u8;
    exports.U8aFixed = U8aFixed;
    exports.UInt = UInt;
    exports.USize = usize;
    exports.Vec = Vec;
    exports.VecFixed = VecFixed;
    exports.WrapperKeepOpaque = WrapperKeepOpaque;
    exports.WrapperOpaque = WrapperOpaque;
    exports.XCM_MAPPINGS = XCM_MAPPINGS;
    exports.bool = bool;
    exports.constructTypeClass = constructTypeClass;
    exports.convertSiV0toV1 = toV1;
    exports.createClass = createClass;
    exports.createClassUnsafe = createClassUnsafe;
    exports.createType = createType;
    exports.createTypeUnsafe = createTypeUnsafe;
    exports.decorateConstants = decorateConstants;
    exports.decorateExtrinsics = decorateExtrinsics;
    exports.decorateStorage = decorateStorage;
    exports.encodeTypeDef = encodeTypeDef;
    exports.expandMetadata = expandMetadata;
    exports.f32 = f32;
    exports.f64 = f64;
    exports.getTypeClass = getTypeClass;
    exports.getTypeDef = getTypeDef;
    exports.i128 = i128;
    exports.i16 = i16;
    exports.i256 = i256;
    exports.i32 = i32;
    exports.i64 = i64;
    exports.i8 = i8;
    exports.isize = isize;
    exports.lazyVariants = lazyVariants;
    exports.mapXcmTypes = mapXcmTypes;
    exports.packageInfo = packageInfo;
    exports.paramsNotation = paramsNotation;
    exports.rpcDefinitions = jsonrpc$1;
    exports.typeDefinitions = definitions;
    exports.typeSplit = typeSplit;
    exports.u128 = u128;
    exports.u16 = u16;
    exports.u256 = u256;
    exports.u32 = u32;
    exports.u64 = u64;
    exports.u8 = u8;
    exports.unwrapStorageType = unwrapStorageType;
    exports.usize = usize;
    exports.withTypeString = withTypeString;

}));