import '@polkadot/api-base/types/storage';
import type { ApiTypes, AugmentedQuery, QueryableStorageEntry } from '@polkadot/api-base/types';
import type { BTreeMap, Bytes, Null, Option, U8aFixed, Vec, WrapperKeepOpaque, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';
import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types';
import type { AccountId32, Call, H256 } from '@polkadot/types/interfaces/runtime';
import type { ChainbridgeProposalVotes, CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueQueueConfigData, EqClaimEthereumAddress, EqDexBestPrice, EqMmPoolEpochInfo, EqMmPoolLenderInfo, EqMmPoolMmInfo, EqMmPoolMmPoolInfo, EqMultisigSudoMultisig, EqNodeRuntimeOpaqueSessionKeys, EqOraclePricePoint, EqPrimitivesAssetAssetData, EqPrimitivesDexOrder, EqPrimitivesSignedBalance, EqPrimitivesSubaccountSubAccType, EqPrimitivesTotalAggregates, EqPrimitivesUserGroup, EqPrimitivesXcmMode, EqRateEd25519AppEd25519Public, EqVestingVestingInfo, EqXdotPoolXdotPoolInfo, EquilibriumCurveAmmPoolInfo, FinancialPalletAssetMetrics, FinancialPalletFinancialMetrics, FinancialPalletPortfolioMetrics, FinancialPalletPriceLog, FinancialPalletPriceUpdate, FrameSupportWeightsPerDispatchClassU64, FrameSystemAccountInfo, FrameSystemEventRecord, FrameSystemLastRuntimeUpgradeInfo, FrameSystemPhase, PalletAuthorshipUncleEntryItem, PalletMultisigMultisig, PalletProxyAnnouncement, PalletProxyProxyDefinition, PalletTransactionPaymentReleases, PalletXcmQueryStatus, PalletXcmVersionMigrationStage, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, SpConsensusAuraSr25519AppSr25519Public, SpCoreCryptoKeyTypeId, SpRuntimeDigest, SpTrieStorageProof, XcmVersionedMultiLocation } from '@polkadot/types/lookup';
import type { Observable } from '@polkadot/types/types';
export declare type __AugmentedQuery<ApiType extends ApiTypes> = AugmentedQuery<ApiType, () => unknown>;
export declare type __QueryableStorageEntry<ApiType extends ApiTypes> = QueryableStorageEntry<ApiType>;
declare module '@polkadot/api-base/types/storage' {
    interface AugmentedQueries<ApiType extends ApiTypes> {
        auraExt: {
            /**
             * Serves as cache for the authorities.
             *
             * The authorities in AuRa are overwritten in `on_initialize` when we switch to a new session,
             * but we require the old authorities to verify the seal when validating a PoV. This will always
             * be updated to the latest AuRa authorities in `on_finalize`.
             **/
            authorities: AugmentedQuery<ApiType, () => Observable<Vec<SpConsensusAuraSr25519AppSr25519Public>>, []>;
        };
        authorship: {
            /**
             * Author of current block.
             **/
            author: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []>;
            /**
             * Whether uncles were already set in this block.
             **/
            didSetUncles: AugmentedQuery<ApiType, () => Observable<bool>, []>;
            /**
             * Uncles
             **/
            uncles: AugmentedQuery<ApiType, () => Observable<Vec<PalletAuthorshipUncleEntryItem>>, []>;
        };
        bailsman: {};
        chainBridge: {
            /**
             * All whitelisted chains and their respective transaction counts.
             **/
            chainNonces: AugmentedQuery<ApiType, (arg: u8 | AnyNumber | Uint8Array) => Observable<Option<u64>>, [u8]>;
            /**
             * Permission to voting and making transfers.
             **/
            disabledChains: AugmentedQuery<ApiType, (arg: u8 | AnyNumber | Uint8Array) => Observable<Null>, [u8]>;
            /**
             * Fee to charge for a bridge transfer S->E.
             **/
            fees: AugmentedQuery<ApiType, (arg: u8 | AnyNumber | Uint8Array) => Observable<u128>, [u8]>;
            /**
             * Time in blocks for relays voting
             **/
            proposalLifetime: AugmentedQuery<ApiType, () => Observable<u32>, []>;
            /**
             * Number of relayers in set.
             **/
            relayerCount: AugmentedQuery<ApiType, () => Observable<u32>, []>;
            /**
             * Tracks current relayer set.
             **/
            relayers: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<bool>, [AccountId32]>;
            /**
             * Number of votes required for a proposal to execute.
             **/
            relayerThreshold: AugmentedQuery<ApiType, () => Observable<u32>, []>;
            /**
             * Utilized by the bridge software to map resource IDs to actual methods.
             **/
            resources: AugmentedQuery<ApiType, (arg: U8aFixed | string | Uint8Array) => Observable<Option<Bytes>>, [U8aFixed]>;
            /**
             * All known proposals.
             * The key is the hash of the call and the deposit ID, to ensure it's unique.
             **/
            votes: AugmentedQuery<ApiType, (arg1: u8 | AnyNumber | Uint8Array, arg2: ITuple<[u64, Call]> | [u64 | AnyNumber | Uint8Array, Call | IMethod | string | Uint8Array]) => Observable<Option<ChainbridgeProposalVotes>>, [u8, ITuple<[u64, Call]>]>;
        };
        claims: {
            /**
             * Pallet storage - stores amount to be claimed by each `EthereumAddress`
             **/
            claims: AugmentedQuery<ApiType, (arg: EqClaimEthereumAddress | string | Uint8Array) => Observable<Option<u128>>, [EqClaimEthereumAddress]>;
            /**
             * Pallet storage - pre-claimed Ethereum accounts, by the Account ID that
             * they are claimed to
             **/
            preclaims: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<U8aFixed>>, [AccountId32]>;
            /**
             * Pallet storage - stores Ethereum addresses from which additional statement
             * singing is required
             **/
            signing: AugmentedQuery<ApiType, (arg: EqClaimEthereumAddress | string | Uint8Array) => Observable<bool>, [EqClaimEthereumAddress]>;
            /**
             * Pallet storage - total `Claims` amount
             **/
            total: AugmentedQuery<ApiType, () => Observable<u128>, []>;
            /**
             * Pallet storage - vesting schedule for a claim.
             * First balance is the total amount that should be held for vesting.
             * Second balance is how much should be unlocked per block.
             * The block number is when the vesting should start.
             **/
            vesting: AugmentedQuery<ApiType, (arg: EqClaimEthereumAddress | string | Uint8Array) => Observable<Option<ITuple<[u128, u128, u32]>>>, [EqClaimEthereumAddress]>;
        };
        curveAmm: {
            /**
             * Current number of pools (also ID for the next created pool)
             **/
            poolCount: AugmentedQuery<ApiType, () => Observable<u32>, []>;
            /**
             * Existing pools
             **/
            pools: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<EquilibriumCurveAmmPoolInfo>>, [u32]>;
        };
        dmpQueue: {
            /**
             * The configuration.
             **/
            configuration: AugmentedQuery<ApiType, () => Observable<CumulusPalletDmpQueueConfigData>, []>;
            /**
             * The overweight messages.
             **/
            overweight: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[u32, Bytes]>>>, [u64]>;
            /**
             * The page index.
             **/
            pageIndex: AugmentedQuery<ApiType, () => Observable<CumulusPalletDmpQueuePageIndexData>, []>;
            /**
             * The queue pages.
             **/
            pages: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[u32, Bytes]>>>, [u32]>;
        };
        eqAggregates: {
            accountUserGroups: AugmentedQuery<ApiType, (arg1: EqPrimitivesUserGroup | 'Unknown' | 'Balances' | 'Bailsmen' | 'Borrowers' | 'Lenders' | number | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<bool>, [EqPrimitivesUserGroup, AccountId32]>;
            /**
             * Pallet storage - stores aggregates for each user group
             **/
            totalUserGroups: AugmentedQuery<ApiType, (arg1: EqPrimitivesUserGroup | 'Unknown' | 'Balances' | 'Bailsmen' | 'Borrowers' | 'Lenders' | number | Uint8Array, arg2: u64 | AnyNumber | Uint8Array) => Observable<EqPrimitivesTotalAggregates>, [EqPrimitivesUserGroup, u64]>;
        };
        eqAssets: {
            assets: AugmentedQuery<ApiType, () => Observable<Option<Vec<EqPrimitivesAssetAssetData>>>, []>;
        };
        eqBalances: {
            /**
             * Pallet storage - balances for all accounts
             **/
            account: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: u64 | AnyNumber | Uint8Array) => Observable<EqPrimitivesSignedBalance>, [AccountId32, u64]>;
            /**
             * Flag for enable/disable transfers
             **/
            isTransfersEnabled: AugmentedQuery<ApiType, () => Observable<bool>, []>;
            /**
             * Stores current xcm executing mode.
             * `None` means for receiving like in `Xcm` mode and no sending.
             **/
            isXcmTransfersEnabled: AugmentedQuery<ApiType, () => Observable<Option<EqPrimitivesXcmMode>>, []>;
            /**
             * Reserved balances
             **/
            reserved: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: u64 | AnyNumber | Uint8Array) => Observable<u128>, [AccountId32, u64]>;
        };
        eqBridge: {
            assetResource: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<U8aFixed>>, [u64]>;
            enabledWithdrawals: AugmentedQuery<ApiType, (arg: U8aFixed | string | Uint8Array) => Observable<Bytes>, [U8aFixed]>;
            minimumTransferAmount: AugmentedQuery<ApiType, (arg1: u8 | AnyNumber | Uint8Array, arg2: U8aFixed | string | Uint8Array) => Observable<u128>, [u8, U8aFixed]>;
            resources: AugmentedQuery<ApiType, (arg: U8aFixed | string | Uint8Array) => Observable<Option<u64>>, [U8aFixed]>;
        };
        eqDex: {
            actualChunksByAsset: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Vec<u64>>, [u64]>;
            /**
             * Keep by every asset (Asset, Sum(amount * price), Sum(amount))
             **/
            assetWeightByAccountId: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<ITuple<[u64, u128, u128]>>>, [AccountId32]>;
            bestPriceByAsset: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<EqDexBestPrice>, [u64]>;
            chunkCorridorByAsset: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<u32>, [u64]>;
            orderIdCounter: AugmentedQuery<ApiType, () => Observable<u64>, []>;
            ordersByAssetAndChunkKey: AugmentedQuery<ApiType, (arg1: u64 | AnyNumber | Uint8Array, arg2: u64 | AnyNumber | Uint8Array) => Observable<Vec<EqPrimitivesDexOrder>>, [u64, u64]>;
        };
        eqInvestors: {
            palletManager: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []>;
        };
        eqLiquidityFarming: {
            palletManager: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []>;
        };
        eqLockdrop: {
            /**
             * Stores flag for on/off setting for offchain worker (unlocks)
             **/
            autoUnlockEnabled: AugmentedQuery<ApiType, () => Observable<bool>, []>;
            /**
             * Pallet storage - accounts locks
             **/
            locks: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u128>, [AccountId32]>;
            /**
             * Pallet storage - start of lock program.
             * Value is UnixTime timestamp in seconds
             **/
            lockStart: AugmentedQuery<ApiType, () => Observable<Option<u64>>, []>;
            /**
             * This is the max amount of unlocks an offchain worker can make
             **/
            maxOffchainUnlocks: AugmentedQuery<ApiType, () => Observable<Option<u64>>, []>;
        };
        eqMarginCall: {
            maintenanceTimers: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<u64>>, [AccountId32]>;
        };
        eqMultisigSudo: {
            /**
             * The multisig signatory key list.
             **/
            keys: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<bool>, [AccountId32]>;
            /**
             * The map storing proposals by a call hash key (CallHash)
             **/
            multisigProposals: AugmentedQuery<ApiType, (arg: U8aFixed | string | Uint8Array) => Observable<Option<EqMultisigSudoMultisig>>, [U8aFixed]>;
            /**
             * The threshold required to proceed a call.
             **/
            threshold: AugmentedQuery<ApiType, () => Observable<u32>, []>;
        };
        eqRate: {
            /**
             * Stores flag for on/off setting for offchain workers (reinits)
             **/
            autoReinitEnabled: AugmentedQuery<ApiType, () => Observable<bool>, []>;
            /**
             * Pallet storage for keys
             **/
            keys: AugmentedQuery<ApiType, () => Observable<Vec<EqRateEd25519AppEd25519Public>>, []>;
            /**
             * Pallet storage - last update timestamps in seconds for each `AccountId` that has balances
             **/
            lastFeeUpdate: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u64>, [AccountId32]>;
            /**
             * Pallet storage used for time offset in test builds. Disabled by "production" feature.
             **/
            nowMillisOffset: AugmentedQuery<ApiType, () => Observable<u64>, []>;
        };
        eqSessionManager: {
            /**
             * Pallet storage - flag showing that active validators list changed
             * during a session
             **/
            isChanged: AugmentedQuery<ApiType, () => Observable<bool>, []>;
            /**
             * Pallet storage - list of all active validators
             **/
            validators: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<bool>, [AccountId32]>;
        };
        eqTreasury: {
            palletManager: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []>;
        };
        financial: {
            /**
             * Financial metrics for all known assets.
             **/
            metrics: AugmentedQuery<ApiType, () => Observable<Option<FinancialPalletFinancialMetrics>>, []>;
            /**
             * Financial metrics on per asset basis.
             **/
            perAssetMetrics: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<FinancialPalletAssetMetrics>>, [u64]>;
            /**
             * Financial metrics on per portfolio basis.
             **/
            perPortfolioMetrics: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<FinancialPalletPortfolioMetrics>>, [AccountId32]>;
            /**
             * Price log on per asset basis.
             **/
            priceLogs: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<FinancialPalletPriceLog>>, [u64]>;
            /**
             * Latest price updates on per asset basis.
             **/
            updates: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<FinancialPalletPriceUpdate>>, [u64]>;
        };
        migration: {
            /**
             * Current migration
             **/
            migration: AugmentedQuery<ApiType, () => Observable<Option<Vec<ITuple<[Bytes, Bytes]>>>>, []>;
        };
        mmPool: {
            /**
             * Storage of all mm pools settings
             **/
            deposits: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<ITuple<[u64, EqMmPoolLenderInfo]>>>, [AccountId32]>;
            epoch: AugmentedQuery<ApiType, () => Observable<EqMmPoolEpochInfo>, []>;
            manager: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []>;
            managers: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<ITuple<[u16, AccountId32]>>>, [AccountId32]>;
            marketMakers: AugmentedQuery<ApiType, (arg: u16 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[u64, EqMmPoolMmInfo]>>>, [u16]>;
            /**
             * Storage of all mm pools settings
             **/
            pools: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u64, EqMmPoolMmPoolInfo]>>>, []>;
        };
        multisig: {
            calls: AugmentedQuery<ApiType, (arg: U8aFixed | string | Uint8Array) => Observable<Option<ITuple<[WrapperKeepOpaque<Call>, AccountId32, u128]>>>, [U8aFixed]>;
            /**
             * The set of open multisig operations.
             **/
            multisigs: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: U8aFixed | string | Uint8Array) => Observable<Option<PalletMultisigMultisig>>, [AccountId32, U8aFixed]>;
        };
        oracle: {
            /**
             * Stores flag for the automatic financial metrics recalculation at the start of each block
             **/
            finMetricsRecalcEnabled: AugmentedQuery<ApiType, () => Observable<bool>, []>;
            /**
             * Pallet storage for added price points
             **/
            pricePoints: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<EqOraclePricePoint>>, [u64]>;
        };
        parachainInfo: {
            parachainId: AugmentedQuery<ApiType, () => Observable<u32>, []>;
        };
        parachainSystem: {
            /**
             * The number of HRMP messages we observed in `on_initialize` and thus used that number for
             * announcing the weight of `on_initialize` and `on_finalize`.
             **/
            announcedHrmpMessagesPerCandidate: AugmentedQuery<ApiType, () => Observable<u32>, []>;
            /**
             * The next authorized upgrade, if there is one.
             **/
            authorizedUpgrade: AugmentedQuery<ApiType, () => Observable<Option<H256>>, []>;
            /**
             * A custom head data that should be returned as result of `validate_block`.
             *
             * See [`Pallet::set_custom_validation_head_data`] for more information.
             **/
            customValidationHeadData: AugmentedQuery<ApiType, () => Observable<Option<Bytes>>, []>;
            /**
             * Were the validation data set to notify the relay chain?
             **/
            didSetValidationCode: AugmentedQuery<ApiType, () => Observable<bool>, []>;
            /**
             * The parachain host configuration that was obtained from the relay parent.
             *
             * This field is meant to be updated each block with the validation data inherent. Therefore,
             * before processing of the inherent, e.g. in `on_initialize` this data may be stale.
             *
             * This data is also absent from the genesis.
             **/
            hostConfiguration: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV2AbridgedHostConfiguration>>, []>;
            /**
             * HRMP messages that were sent in a block.
             *
             * This will be cleared in `on_initialize` of each new block.
             **/
            hrmpOutboundMessages: AugmentedQuery<ApiType, () => Observable<Vec<PolkadotCorePrimitivesOutboundHrmpMessage>>, []>;
            /**
             * HRMP watermark that was set in a block.
             *
             * This will be cleared in `on_initialize` of each new block.
             **/
            hrmpWatermark: AugmentedQuery<ApiType, () => Observable<u32>, []>;
            /**
             * The last downward message queue chain head we have observed.
             *
             * This value is loaded before and saved after processing inbound downward messages carried
             * by the system inherent.
             **/
            lastDmqMqcHead: AugmentedQuery<ApiType, () => Observable<H256>, []>;
            /**
             * The message queue chain heads we have observed per each channel incoming channel.
             *
             * This value is loaded before and saved after processing inbound downward messages carried
             * by the system inherent.
             **/
            lastHrmpMqcHeads: AugmentedQuery<ApiType, () => Observable<BTreeMap<u32, H256>>, []>;
            /**
             * Validation code that is set by the parachain and is to be communicated to collator and
             * consequently the relay-chain.
             *
             * This will be cleared in `on_initialize` of each new block if no other pallet already set
             * the value.
             **/
            newValidationCode: AugmentedQuery<ApiType, () => Observable<Option<Bytes>>, []>;
            /**
             * Upward messages that are still pending and not yet send to the relay chain.
             **/
            pendingUpwardMessages: AugmentedQuery<ApiType, () => Observable<Vec<Bytes>>, []>;
            /**
             * In case of a scheduled upgrade, this storage field contains the validation code to be applied.
             *
             * As soon as the relay chain gives us the go-ahead signal, we will overwrite the [`:code`][well_known_keys::CODE]
             * which will result the next block process with the new validation code. This concludes the upgrade process.
             *
             * [well_known_keys::CODE]: sp_core::storage::well_known_keys::CODE
             **/
            pendingValidationCode: AugmentedQuery<ApiType, () => Observable<Bytes>, []>;
            /**
             * Number of downward messages processed in a block.
             *
             * This will be cleared in `on_initialize` of each new block.
             **/
            processedDownwardMessages: AugmentedQuery<ApiType, () => Observable<u32>, []>;
            /**
             * The state proof for the last relay parent block.
             *
             * This field is meant to be updated each block with the validation data inherent. Therefore,
             * before processing of the inherent, e.g. in `on_initialize` this data may be stale.
             *
             * This data is also absent from the genesis.
             **/
            relayStateProof: AugmentedQuery<ApiType, () => Observable<Option<SpTrieStorageProof>>, []>;
            /**
             * The snapshot of some state related to messaging relevant to the current parachain as per
             * the relay parent.
             *
             * This field is meant to be updated each block with the validation data inherent. Therefore,
             * before processing of the inherent, e.g. in `on_initialize` this data may be stale.
             *
             * This data is also absent from the genesis.
             **/
            relevantMessagingState: AugmentedQuery<ApiType, () => Observable<Option<CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot>>, []>;
            /**
             * The weight we reserve at the beginning of the block for processing DMP messages. This
             * overrides the amount set in the Config trait.
             **/
            reservedDmpWeightOverride: AugmentedQuery<ApiType, () => Observable<Option<u64>>, []>;
            /**
             * The weight we reserve at the beginning of the block for processing XCMP messages. This
             * overrides the amount set in the Config trait.
             **/
            reservedXcmpWeightOverride: AugmentedQuery<ApiType, () => Observable<Option<u64>>, []>;
            /**
             * An option which indicates if the relay-chain restricts signalling a validation code upgrade.
             * In other words, if this is `Some` and [`NewValidationCode`] is `Some` then the produced
             * candidate will be invalid.
             *
             * This storage item is a mirror of the corresponding value for the current parachain from the
             * relay-chain. This value is ephemeral which means it doesn't hit the storage. This value is
             * set after the inherent.
             **/
            upgradeRestrictionSignal: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV2UpgradeRestriction>>, []>;
            /**
             * Upward messages that were sent in a block.
             *
             * This will be cleared in `on_initialize` of each new block.
             **/
            upwardMessages: AugmentedQuery<ApiType, () => Observable<Vec<Bytes>>, []>;
            /**
             * The [`PersistedValidationData`] set for this block.
             * This value is expected to be set only once per block and it's never stored
             * in the trie.
             **/
            validationData: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV2PersistedValidationData>>, []>;
        };
        polkadotXcm: {
            /**
             * The existing asset traps.
             *
             * Key is the blake2 256 hash of (origin, versioned `MultiAssets`) pair. Value is the number of
             * times this pair has been trapped (usually just 1 if it exists at all).
             **/
            assetTraps: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<u32>, [H256]>;
            /**
             * The current migration's stage, if any.
             **/
            currentMigration: AugmentedQuery<ApiType, () => Observable<Option<PalletXcmVersionMigrationStage>>, []>;
            /**
             * The ongoing queries.
             **/
            queries: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<PalletXcmQueryStatus>>, [u64]>;
            /**
             * The latest available query index.
             **/
            queryCounter: AugmentedQuery<ApiType, () => Observable<u64>, []>;
            /**
             * Default version to encode XCM when latest version of destination is unknown. If `None`,
             * then the destinations whose XCM version is unknown are considered unreachable.
             **/
            safeXcmVersion: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []>;
            /**
             * The Latest versions that we know various locations support.
             **/
            supportedVersion: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: XcmVersionedMultiLocation | {
                V0: any;
            } | {
                V1: any;
            } | string | Uint8Array) => Observable<Option<u32>>, [u32, XcmVersionedMultiLocation]>;
            /**
             * Destinations whose latest XCM version we would like to know. Duplicates not allowed, and
             * the `u32` counter is the number of times that a send to the destination has been attempted,
             * which is used as a prioritization.
             **/
            versionDiscoveryQueue: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[XcmVersionedMultiLocation, u32]>>>, []>;
            /**
             * All locations that we have requested version notifications from.
             **/
            versionNotifiers: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: XcmVersionedMultiLocation | {
                V0: any;
            } | {
                V1: any;
            } | string | Uint8Array) => Observable<Option<u64>>, [u32, XcmVersionedMultiLocation]>;
            /**
             * The target locations that are subscribed to our version changes, as well as the most recent
             * of our versions we informed them of.
             **/
            versionNotifyTargets: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: XcmVersionedMultiLocation | {
                V0: any;
            } | {
                V1: any;
            } | string | Uint8Array) => Observable<Option<ITuple<[u64, u64, u32]>>>, [u32, XcmVersionedMultiLocation]>;
        };
        proxy: {
            /**
             * The announcements made by the proxy (key).
             **/
            announcements: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<ITuple<[Vec<PalletProxyAnnouncement>, u128]>>, [AccountId32]>;
            /**
             * The set of account proxies. Maps the account which has delegated to the accounts
             * which are being delegated to, together with the amount held on deposit.
             **/
            proxies: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<ITuple<[Vec<PalletProxyProxyDefinition>, u128]>>, [AccountId32]>;
        };
        randomnessCollectiveFlip: {
            /**
             * Series of block headers from the last 81 blocks that acts as random seed material. This
             * is arranged as a ring buffer with `block_number % 81` being the index into the `Vec` of
             * the oldest hash.
             **/
            randomMaterial: AugmentedQuery<ApiType, () => Observable<Vec<H256>>, []>;
        };
        republic: {
            palletManager: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []>;
        };
        session: {
            /**
             * Current index of the session.
             **/
            currentIndex: AugmentedQuery<ApiType, () => Observable<u32>, []>;
            /**
             * Indices of disabled validators.
             *
             * The vec is always kept sorted so that we can find whether a given validator is
             * disabled using binary search. It gets cleared when `on_session_ending` returns
             * a new set of identities.
             **/
            disabledValidators: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []>;
            /**
             * The owner of a key. The key is the `KeyTypeId` + the encoded key.
             **/
            keyOwner: AugmentedQuery<ApiType, (arg: ITuple<[SpCoreCryptoKeyTypeId, Bytes]> | [SpCoreCryptoKeyTypeId | string | Uint8Array, Bytes | string | Uint8Array]) => Observable<Option<AccountId32>>, [ITuple<[SpCoreCryptoKeyTypeId, Bytes]>]>;
            /**
             * The next session keys for a validator.
             **/
            nextKeys: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<EqNodeRuntimeOpaqueSessionKeys>>, [AccountId32]>;
            /**
             * True if the underlying economic identities or weighting behind the validators
             * has changed in the queued validator set.
             **/
            queuedChanged: AugmentedQuery<ApiType, () => Observable<bool>, []>;
            /**
             * The queued keys for the next session. When the next session begins, these keys
             * will be used to determine the validator's session keys.
             **/
            queuedKeys: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[AccountId32, EqNodeRuntimeOpaqueSessionKeys]>>>, []>;
            /**
             * The current set of validators.
             **/
            validators: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []>;
        };
        subaccounts: {
            /**
             * Pallet storage - a map storing a tuple  (`AccountId`, `SubAccType`)
             * for each existing subaccount. First element in stored tuple is
             * `AccountId` of main user account, owning the subaccount and second
             * is `SubAccType` of key subaccount
             **/
            ownerAccount: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<ITuple<[AccountId32, EqPrimitivesSubaccountSubAccType]>>>, [AccountId32]>;
            /**
             * Pallet storage - double map storing subaccounts as `AccountId` where
             * user's main `AccountId` and `SubAccType` used as keys
             **/
            subaccount: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: EqPrimitivesSubaccountSubAccType | 'Bailsman' | 'Borrower' | 'Lender' | number | Uint8Array) => Observable<Option<AccountId32>>, [AccountId32, EqPrimitivesSubaccountSubAccType]>;
        };
        system: {
            /**
             * The full account information for a particular account ID.
             **/
            account: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<FrameSystemAccountInfo>, [AccountId32]>;
            /**
             * Total length (in bytes) for all extrinsics put together, for the current block.
             **/
            allExtrinsicsLen: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []>;
            /**
             * Map of block numbers to block hashes.
             **/
            blockHash: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<H256>, [u32]>;
            /**
             * The current weight for the block.
             **/
            blockWeight: AugmentedQuery<ApiType, () => Observable<FrameSupportWeightsPerDispatchClassU64>, []>;
            /**
             * Digest of the current block, also part of the block header.
             **/
            digest: AugmentedQuery<ApiType, () => Observable<SpRuntimeDigest>, []>;
            /**
             * The number of events in the `Events<T>` list.
             **/
            eventCount: AugmentedQuery<ApiType, () => Observable<u32>, []>;
            /**
             * Events deposited for the current block.
             *
             * NOTE: The item is unbound and should therefore never be read on chain.
             * It could otherwise inflate the PoV size of a block.
             *
             * Events have a large in-memory size. Box the events to not go out-of-memory
             * just in case someone still reads them from within the runtime.
             **/
            events: AugmentedQuery<ApiType, () => Observable<Vec<FrameSystemEventRecord>>, []>;
            /**
             * Mapping between a topic (represented by T::Hash) and a vector of indexes
             * of events in the `<Events<T>>` list.
             *
             * All topic vectors have deterministic storage locations depending on the topic. This
             * allows light-clients to leverage the changes trie storage tracking mechanism and
             * in case of changes fetch the list of events of interest.
             *
             * The value has the type `(T::BlockNumber, EventIndex)` because if we used only just
             * the `EventIndex` then in case if the topic has the same contents on the next block
             * no notification will be triggered thus the event might be lost.
             **/
            eventTopics: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Vec<ITuple<[u32, u32]>>>, [H256]>;
            /**
             * The execution phase of the block.
             **/
            executionPhase: AugmentedQuery<ApiType, () => Observable<Option<FrameSystemPhase>>, []>;
            /**
             * Total extrinsics count for the current block.
             **/
            extrinsicCount: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []>;
            /**
             * Extrinsics data for the current block (maps an extrinsic's index to its data).
             **/
            extrinsicData: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]>;
            /**
             * Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened.
             **/
            lastRuntimeUpgrade: AugmentedQuery<ApiType, () => Observable<Option<FrameSystemLastRuntimeUpgradeInfo>>, []>;
            /**
             * The current block number being processed. Set by `execute_block`.
             **/
            number: AugmentedQuery<ApiType, () => Observable<u32>, []>;
            /**
             * Hash of the previous block.
             **/
            parentHash: AugmentedQuery<ApiType, () => Observable<H256>, []>;
            /**
             * True if we have upgraded so that AccountInfo contains three types of `RefCount`. False
             * (default) if not.
             **/
            upgradedToTripleRefCount: AugmentedQuery<ApiType, () => Observable<bool>, []>;
            /**
             * True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.
             **/
            upgradedToU32RefCount: AugmentedQuery<ApiType, () => Observable<bool>, []>;
        };
        timestamp: {
            /**
             * Did the timestamp get updated in this block?
             **/
            didUpdate: AugmentedQuery<ApiType, () => Observable<bool>, []>;
            /**
             * Current time for the current block.
             **/
            now: AugmentedQuery<ApiType, () => Observable<u64>, []>;
        };
        transactionPayment: {
            nextFeeMultiplier: AugmentedQuery<ApiType, () => Observable<u128>, []>;
            storageVersion: AugmentedQuery<ApiType, () => Observable<PalletTransactionPaymentReleases>, []>;
        };
        treasury: {};
        vesting: {
            /**
             * Pallet storage: information about already vested balances for given account
             **/
            vested: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<u128>>, [AccountId32]>;
            /**
             * Pallet storage: information regarding the vesting of a given account
             **/
            vesting: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<EqVestingVestingInfo>>, [AccountId32]>;
        };
        vesting2: {
            /**
             * Pallet storage: information about already vested balances for given account
             **/
            vested: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<u128>>, [AccountId32]>;
            /**
             * Pallet storage: information regarding the vesting of a given account
             **/
            vesting: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<EqVestingVestingInfo>>, [AccountId32]>;
        };
        whitelists: {
            /**
             * Storage of all whitelisted `AccountId`s
             **/
            whiteList: AugmentedQuery<ApiType, () => Observable<Option<Vec<AccountId32>>>, []>;
        };
        xcmpQueue: {
            /**
             * Inbound aggregate XCMP messages. It can only be one per ParaId/block.
             **/
            inboundXcmpMessages: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32, u32]>;
            /**
             * Status of the inbound XCMP channels.
             **/
            inboundXcmpStatus: AugmentedQuery<ApiType, () => Observable<Vec<CumulusPalletXcmpQueueInboundChannelDetails>>, []>;
            /**
             * The messages outbound in a given XCMP channel.
             **/
            outboundXcmpMessages: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u16 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32, u16]>;
            /**
             * The non-empty XCMP channels in order of becoming non-empty, and the index of the first
             * and last outbound message. If the two indices are equal, then it indicates an empty
             * queue and there must be a non-`Ok` `OutboundStatus`. We assume queues grow no greater
             * than 65535 items. Queue indices for normal messages begin at one; zero is reserved in
             * case of the need to send a high-priority signal message this block.
             * The bool is true if there is a signal message waiting to be sent.
             **/
            outboundXcmpStatus: AugmentedQuery<ApiType, () => Observable<Vec<CumulusPalletXcmpQueueOutboundChannelDetails>>, []>;
            /**
             * The messages that exceeded max individual message weight budget.
             *
             * These message stay in this storage map until they are manually dispatched via
             * `service_overweight`.
             **/
            overweight: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[u32, u32, Bytes]>>>, [u64]>;
            /**
             * The number of overweight messages ever recorded in `Overweight`. Also doubles as the next
             * available free overweight index.
             **/
            overweightCount: AugmentedQuery<ApiType, () => Observable<u64>, []>;
            /**
             * The configuration which controls the dynamics of the outbound queue.
             **/
            queueConfig: AugmentedQuery<ApiType, () => Observable<CumulusPalletXcmpQueueQueueConfigData>, []>;
            /**
             * Whether or not the XCMP queue is suspended from executing incoming XCMs or not.
             **/
            queueSuspended: AugmentedQuery<ApiType, () => Observable<bool>, []>;
            /**
             * Any signal messages waiting to be sent.
             **/
            signalMessages: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]>;
        };
        xdot: {
            initializer: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<AccountId32>>, [u32]>;
            /**
             * Current number of pools (also ID for the next created pool)
             **/
            poolCount: AugmentedQuery<ApiType, () => Observable<u32>, []>;
            pools: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<EqXdotPoolXdotPoolInfo>>, [u32]>;
        };
    }
}
