@bifrost-finance/types/augment/api-query.d.ts

Bifrost JS types

import '@polkadot/api-base/types/storage';
import type { AccountId32, Call, H256, Perbill, Percent, Permill } from '@bifrost-finance/types/interfaces/runtime';
import type { ApiTypes, AugmentedQuery, QueryableStorageEntry } from '@polkadot/api-base/types';
import type { Data } from '@polkadot/types';
import type { BTreeMap, BTreeSet, Bytes, Null, Option, U256, U8aFixed, Vec, bool, i32, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';
import type { AnyNumber, ITuple } from '@polkadot/types-codec/types';
import type { BifrostAssetRegistryAssetMetadata, BifrostFarmingBoostBoostPoolInfo, BifrostFarmingBoostUserBoostInfo, BifrostFarmingGaugeGaugeInfo, BifrostFarmingGaugeGaugePoolInfo, BifrostFarmingRewardsPoolInfo, BifrostFarmingRewardsShareInfo, BifrostFeeShareInfo, BifrostKusamaRuntimeSessionKeys, BifrostLiquidityMiningDepositData, BifrostLiquidityMiningPoolInfo, BifrostLiquidityMiningStorageVersion, BifrostSalpFundInfo, BifrostSalpLiteFundInfo, BifrostSlpPrimitivesDelays, BifrostSlpPrimitivesLedger, BifrostSlpPrimitivesLedgerUpdateEntry, BifrostSlpPrimitivesMinimumsMaximums, BifrostSlpPrimitivesValidatorsByDelegatorUpdateEntry, BifrostSlpPrimitivesXcmOperation, BifrostSystemMakerInfo, BifrostSystemStakingRoundInfo, BifrostSystemStakingTokenInfo, BifrostVestingVestingInfo, BifrostVsbondAuctionOrderInfo, BifrostVsbondAuctionOrderType, BifrostVstokenConversionPrimitivesVstokenConversionExchangeFee, BifrostVstokenConversionPrimitivesVstokenConversionExchangeRate, CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueQueueConfigData, FrameSupportDispatchPerDispatchClassWeight, FrameSupportPreimagesBounded, FrameSystemAccountInfo, FrameSystemEventRecord, FrameSystemLastRuntimeUpgradeInfo, FrameSystemPhase, MerkleDistributorMerkleMetadata, NodePrimitivesCurrencyAssetIds, NodePrimitivesCurrencyCurrencyId, NodePrimitivesTimeUnit, OrmlTokensAccountData, OrmlTokensBalanceLock, OrmlTokensReserveData, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesReserveData, PalletBountiesBounty, PalletCollectiveVotes, PalletDemocracyReferendumInfo, PalletDemocracyVoteThreshold, PalletDemocracyVoteVoting, PalletElectionsPhragmenSeatHolder, PalletElectionsPhragmenVoter, PalletIdentityRegistrarInfo, PalletIdentityRegistration, PalletMultisigMultisig, PalletPreimageRequestStatus, PalletProxyAnnouncement, PalletProxyProxyDefinition, PalletSchedulerScheduled, PalletTipsOpenTip, PalletTransactionPaymentReleases, PalletTreasuryProposal, PalletXcmQueryStatus, PalletXcmRemoteLockedFungibleRecord, PalletXcmVersionMigrationStage, ParachainStakingBond, ParachainStakingCandidateMetadata, ParachainStakingCollatorSnapshot, ParachainStakingDelayedPayout, ParachainStakingDelegationRequestsScheduledRequest, ParachainStakingDelegations, ParachainStakingDelegator, ParachainStakingInflationInflationInfo, ParachainStakingParachainBondConfig, ParachainStakingRoundInfo, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, SpConsensusAuraSr25519AppSr25519Public, SpCoreCryptoKeyTypeId, SpRuntimeDigest, SpTrieStorageProof, SpWeightsWeightV2Weight, XcmInterfaceXcmInterfaceOperation, XcmV2MultiLocation, XcmV3MultiLocation, XcmVersionedAssetId, XcmVersionedMultiLocation, ZenlinkProtocolPrimitivesAssetId, ZenlinkProtocolPrimitivesPairStatus, ZenlinkStableAmmPrimitivesPool } from '@polkadot/types/lookup';
import type { Observable } from '@polkadot/types/types';
export type __AugmentedQuery<ApiType extends ApiTypes> = AugmentedQuery<ApiType, () => unknown>;
export type __QueryableStorageEntry<ApiType extends ApiTypes> = QueryableStorageEntry<ApiType>;
declare module '@polkadot/api-base/types/storage' {
    interface AugmentedQueries<ApiType extends ApiTypes> {
        assetRegistry: {
            /**
             * The storages for AssetMetadatas.
             *
             * AssetMetadatas: map AssetIds => Option<AssetMetadata>
             **/
            assetMetadatas: AugmentedQuery<ApiType, (arg: NodePrimitivesCurrencyAssetIds | {
                ForeignAssetId: any;
            } | {
                NativeAssetId: any;
            } | string | Uint8Array) => Observable<Option<BifrostAssetRegistryAssetMetadata>>, [NodePrimitivesCurrencyAssetIds]> & QueryableStorageEntry<ApiType, [NodePrimitivesCurrencyAssetIds]>;
            /**
             * The storages for MultiLocations.
             *
             * CurrencyIdToLocations: map CurrencyId => Option<MultiLocation>
             **/
            currencyIdToLocations: AugmentedQuery<ApiType, (arg: NodePrimitivesCurrencyCurrencyId | {
                Native: any;
            } | {
                VToken: any;
            } | {
                Token: any;
            } | {
                Stable: any;
            } | {
                VSToken: any;
            } | {
                VSBond: any;
            } | {
                LPToken: any;
            } | {
                ForeignAsset: any;
            } | {
                Token2: any;
            } | {
                VToken2: any;
            } | {
                VSToken2: any;
            } | {
                VSBond2: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<Option<XcmV3MultiLocation>>, [NodePrimitivesCurrencyCurrencyId]> & QueryableStorageEntry<ApiType, [NodePrimitivesCurrencyCurrencyId]>;
            currencyIdToWeights: AugmentedQuery<ApiType, (arg: NodePrimitivesCurrencyCurrencyId | {
                Native: any;
            } | {
                VToken: any;
            } | {
                Token: any;
            } | {
                Stable: any;
            } | {
                VSToken: any;
            } | {
                VSBond: any;
            } | {
                LPToken: any;
            } | {
                ForeignAsset: any;
            } | {
                Token2: any;
            } | {
                VToken2: any;
            } | {
                VSToken2: any;
            } | {
                VSBond2: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<Option<SpWeightsWeightV2Weight>>, [NodePrimitivesCurrencyCurrencyId]> & QueryableStorageEntry<ApiType, [NodePrimitivesCurrencyCurrencyId]>;
            /**
             * The storages for AssetMetadata.
             *
             * CurrencyMetadatas: map CurrencyId => Option<AssetMetadata>
             **/
            currencyMetadatas: AugmentedQuery<ApiType, (arg: NodePrimitivesCurrencyCurrencyId | {
                Native: any;
            } | {
                VToken: any;
            } | {
                Token: any;
            } | {
                Stable: any;
            } | {
                VSToken: any;
            } | {
                VSBond: any;
            } | {
                LPToken: any;
            } | {
                ForeignAsset: any;
            } | {
                Token2: any;
            } | {
                VToken2: any;
            } | {
                VSToken2: any;
            } | {
                VSBond2: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<Option<BifrostAssetRegistryAssetMetadata>>, [NodePrimitivesCurrencyCurrencyId]> & QueryableStorageEntry<ApiType, [NodePrimitivesCurrencyCurrencyId]>;
            /**
             * The storages for CurrencyIds.
             *
             * LocationToCurrencyIds: map MultiLocation => Option<CurrencyId>
             **/
            locationToCurrencyIds: AugmentedQuery<ApiType, (arg: XcmV3MultiLocation | {
                parents?: any;
                interior?: any;
            } | string | Uint8Array) => Observable<Option<NodePrimitivesCurrencyCurrencyId>>, [XcmV3MultiLocation]> & QueryableStorageEntry<ApiType, [XcmV3MultiLocation]>;
            /**
             * Next available Foreign AssetId ID.
             *
             * NextForeignAssetId: ForeignAssetId
             **/
            nextForeignAssetId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Next available TokenId ID.
             *
             * NextTokenId: TokenId
             **/
            nextTokenId: AugmentedQuery<ApiType, () => Observable<u8>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        aura: {
            /**
             * The current authority set.
             **/
            authorities: AugmentedQuery<ApiType, () => Observable<Vec<SpConsensusAuraSr25519AppSr25519Public>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The current slot of this block.
             *
             * This will be set in `on_initialize`.
             **/
            currentSlot: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        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>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        authorship: {
            /**
             * Author of current block.
             **/
            author: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        balances: {
            /**
             * The Balances pallet example of storing the balance of an account.
             *
             * # Example
             *
             * ```nocompile
             * impl pallet_balances::Config for Runtime {
             * type AccountStore = StorageMapShim<Self::Account<Runtime>, frame_system::Provider<Runtime>, AccountId, Self::AccountData<Balance>>
             * }
             * ```
             *
             * You can also store the balance of an account in the `System` pallet.
             *
             * # Example
             *
             * ```nocompile
             * impl pallet_balances::Config for Runtime {
             * type AccountStore = System
             * }
             * ```
             *
             * But this comes with tradeoffs, storing account balances in the system pallet stores
             * `frame_system` data alongside the account data contrary to storing account balances in the
             * `Balances` pallet, which uses a `StorageMap` to store balances data only.
             * NOTE: This is only used in the case that this pallet is used to store balances.
             **/
            account: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<PalletBalancesAccountData>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * The total units of outstanding deactivated balance in the system.
             **/
            inactiveIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Any liquidity locks on some account balances.
             * NOTE: Should only be accessed when setting, changing and freeing a lock.
             **/
            locks: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesBalanceLock>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Named reserves on some account balances.
             **/
            reserves: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesReserveData>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * The total units issued in the system.
             **/
            totalIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        bounties: {
            /**
             * Bounties that have been made.
             **/
            bounties: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletBountiesBounty>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * Bounty indices that have been approved but not yet funded.
             **/
            bountyApprovals: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Number of bounty proposals that have been made.
             **/
            bountyCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The description of each bounty.
             **/
            bountyDescriptions: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<Bytes>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        callSwitchgear: {
            disabledTransfers: AugmentedQuery<ApiType, (arg: NodePrimitivesCurrencyCurrencyId | {
                Native: any;
            } | {
                VToken: any;
            } | {
                Token: any;
            } | {
                Stable: any;
            } | {
                VSToken: any;
            } | {
                VSBond: any;
            } | {
                LPToken: any;
            } | {
                ForeignAsset: any;
            } | {
                Token2: any;
            } | {
                VToken2: any;
            } | {
                VSToken2: any;
            } | {
                VSBond2: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<Option<Null>>, [NodePrimitivesCurrencyCurrencyId]> & QueryableStorageEntry<ApiType, [NodePrimitivesCurrencyCurrencyId]>;
            /**
             * Controls whether or not all of the pallets are banned.
             **/
            overallToggle: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
            switchedOffTransactions: AugmentedQuery<ApiType, (arg: ITuple<[Bytes, Bytes]> | [Bytes | string | Uint8Array, Bytes | string | Uint8Array]) => Observable<Option<Null>>, [ITuple<[Bytes, Bytes]>]> & QueryableStorageEntry<ApiType, [ITuple<[Bytes, Bytes]>]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        council: {
            /**
             * The current members of the collective. This is stored sorted (just by value).
             **/
            members: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The prime member that helps determine the default vote behavior in case of absentations.
             **/
            prime: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Proposals so far.
             **/
            proposalCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Actual proposal for a given hash, if it's current.
             **/
            proposalOf: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<Call>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
            /**
             * The hashes of the active proposals.
             **/
            proposals: AugmentedQuery<ApiType, () => Observable<Vec<H256>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Votes on a given proposal, if it is ongoing.
             **/
            voting: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<PalletCollectiveVotes>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        councilMembership: {
            /**
             * The current membership, stored as an ordered Vec.
             **/
            members: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The current prime member, if one exists.
             **/
            prime: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        crossInOut: {
            /**
             * Mapping a Bifrost account to a multilocation of a outer chain
             **/
            accountToOuterMultilocation: AugmentedQuery<ApiType, (arg1: NodePrimitivesCurrencyCurrencyId | {
                Native: any;
            } | {
                VToken: any;
            } | {
                Token: any;
            } | {
                Stable: any;
            } | {
                VSToken: any;
            } | {
                VSBond: any;
            } | {
                LPToken: any;
            } | {
                ForeignAsset: any;
            } | {
                Token2: any;
            } | {
                VToken2: any;
            } | {
                VSToken2: any;
            } | {
                VSBond2: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<XcmV2MultiLocation>>, [NodePrimitivesCurrencyCurrencyId, AccountId32]> & QueryableStorageEntry<ApiType, [NodePrimitivesCurrencyCurrencyId, AccountId32]>;
            /**
             * To store currencies that support indirect cross-in and cross-out.
             **/
            crossCurrencyRegistry: AugmentedQuery<ApiType, (arg: NodePrimitivesCurrencyCurrencyId | {
                Native: any;
            } | {
                VToken: any;
            } | {
                Token: any;
            } | {
                Stable: any;
            } | {
                VSToken: any;
            } | {
                VSBond: any;
            } | {
                LPToken: any;
            } | {
                ForeignAsset: any;
            } | {
                Token2: any;
            } | {
                VToken2: any;
            } | {
                VSToken2: any;
            } | {
                VSBond2: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<Option<Null>>, [NodePrimitivesCurrencyCurrencyId]> & QueryableStorageEntry<ApiType, [NodePrimitivesCurrencyCurrencyId]>;
            /**
             * minimum crossin and crossout amount【crossinMinimum, crossoutMinimum】
             **/
            crossingMinimumAmount: AugmentedQuery<ApiType, (arg: NodePrimitivesCurrencyCurrencyId | {
                Native: any;
            } | {
                VToken: any;
            } | {
                Token: any;
            } | {
                Stable: any;
            } | {
                VSToken: any;
            } | {
                VSBond: any;
            } | {
                LPToken: any;
            } | {
                ForeignAsset: any;
            } | {
                Token2: any;
            } | {
                VToken2: any;
            } | {
                VSToken2: any;
            } | {
                VSBond2: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<Option<ITuple<[u128, u128]>>>, [NodePrimitivesCurrencyCurrencyId]> & QueryableStorageEntry<ApiType, [NodePrimitivesCurrencyCurrencyId]>;
            /**
             * Accounts in the whitelist can issue the corresponding Currency.
             **/
            issueWhiteList: AugmentedQuery<ApiType, (arg: NodePrimitivesCurrencyCurrencyId | {
                Native: any;
            } | {
                VToken: any;
            } | {
                Token: any;
            } | {
                Stable: any;
            } | {
                VSToken: any;
            } | {
                VSBond: any;
            } | {
                LPToken: any;
            } | {
                ForeignAsset: any;
            } | {
                Token2: any;
            } | {
                VToken2: any;
            } | {
                VSToken2: any;
            } | {
                VSBond2: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<Option<Vec<AccountId32>>>, [NodePrimitivesCurrencyCurrencyId]> & QueryableStorageEntry<ApiType, [NodePrimitivesCurrencyCurrencyId]>;
            /**
             * Mapping a multilocation of a outer chain to a Bifrost account
             **/
            outerMultilocationToAccount: AugmentedQuery<ApiType, (arg1: NodePrimitivesCurrencyCurrencyId | {
                Native: any;
            } | {
                VToken: any;
            } | {
                Token: any;
            } | {
                Stable: any;
            } | {
                VSToken: any;
            } | {
                VSBond: any;
            } | {
                LPToken: any;
            } | {
                ForeignAsset: any;
            } | {
                Token2: any;
            } | {
                VToken2: any;
            } | {
                VSToken2: any;
            } | {
                VSBond2: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, arg2: XcmV2MultiLocation | {
                parents?: any;
                interior?: any;
            } | string | Uint8Array) => Observable<Option<AccountId32>>, [NodePrimitivesCurrencyCurrencyId, XcmV2MultiLocation]> & QueryableStorageEntry<ApiType, [NodePrimitivesCurrencyCurrencyId, XcmV2MultiLocation]>;
            /**
             * Accounts in the whitelist can register the mapping between a multilocation and an accountId.
             **/
            registerWhiteList: AugmentedQuery<ApiType, (arg: NodePrimitivesCurrencyCurrencyId | {
                Native: any;
            } | {
                VToken: any;
            } | {
                Token: any;
            } | {
                Stable: any;
            } | {
                VSToken: any;
            } | {
                VSBond: any;
            } | {
                LPToken: any;
            } | {
                ForeignAsset: any;
            } | {
                Token2: any;
            } | {
                VToken2: any;
            } | {
                VSToken2: any;
            } | {
                VSBond2: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<Option<Vec<AccountId32>>>, [NodePrimitivesCurrencyCurrencyId]> & QueryableStorageEntry<ApiType, [NodePrimitivesCurrencyCurrencyId]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        democracy: {
            /**
             * A record of who vetoed what. Maps proposal hash to a possible existent block number
             * (until when it may not be resubmitted) and who vetoed it.
             **/
            blacklist: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<ITuple<[u32, Vec<AccountId32>]>>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
            /**
             * Record of all proposals that have been subject to emergency cancellation.
             **/
            cancellations: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<bool>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
            /**
             * Those who have locked a deposit.
             *
             * TWOX-NOTE: Safe, as increasing integer keys are safe.
             **/
            depositOf: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[Vec<AccountId32>, u128]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * True if the last referendum tabled was submitted externally. False if it was a public
             * proposal.
             **/
            lastTabledWasExternal: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The lowest referendum index representing an unbaked referendum. Equal to
             * `ReferendumCount` if there isn't a unbaked referendum.
             **/
            lowestUnbaked: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The referendum to be tabled whenever it would be valid to table an external proposal.
             * This happens when a referendum needs to be tabled and one of two conditions are met:
             * - `LastTabledWasExternal` is `false`; or
             * - `PublicProps` is empty.
             **/
            nextExternal: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[FrameSupportPreimagesBounded, PalletDemocracyVoteThreshold]>>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The number of (public) proposals that have been made so far.
             **/
            publicPropCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The public proposals. Unsorted. The second item is the proposal.
             **/
            publicProps: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, FrameSupportPreimagesBounded, AccountId32]>>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The next free referendum index, aka the number of referenda started so far.
             **/
            referendumCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Information concerning any given referendum.
             *
             * TWOX-NOTE: SAFE as indexes are not under an attacker’s control.
             **/
            referendumInfoOf: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletDemocracyReferendumInfo>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * All votes for a particular voter. We store the balance for the number of votes that we
             * have recorded. The second item is the total amount of delegations, that will be added.
             *
             * TWOX-NOTE: SAFE as `AccountId`s are crypto hashes anyway.
             **/
            votingOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<PalletDemocracyVoteVoting>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        dmpQueue: {
            /**
             * The configuration.
             **/
            configuration: AugmentedQuery<ApiType, () => Observable<CumulusPalletDmpQueueConfigData>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Counter for the related counted storage map
             **/
            counterForOverweight: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The overweight messages.
             **/
            overweight: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[u32, Bytes]>>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;
            /**
             * The page index.
             **/
            pageIndex: AugmentedQuery<ApiType, () => Observable<CumulusPalletDmpQueuePageIndexData>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The queue pages.
             **/
            pages: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[u32, Bytes]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        farming: {
            boostBasicRewards: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: NodePrimitivesCurrencyCurrencyId | {
                Native: any;
            } | {
                VToken: any;
            } | {
                Token: any;
            } | {
                Stable: any;
            } | {
                VSToken: any;
            } | {
                VSBond: any;
            } | {
                LPToken: any;
            } | {
                ForeignAsset: any;
            } | {
                Token2: any;
            } | {
                VToken2: any;
            } | {
                VSToken2: any;
            } | {
                VSBond2: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<Option<u128>>, [u32, NodePrimitivesCurrencyCurrencyId]> & QueryableStorageEntry<ApiType, [u32, NodePrimitivesCurrencyCurrencyId]>;
            boostNextRoundWhitelist: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<Null>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            boostPoolInfos: AugmentedQuery<ApiType, () => Observable<BifrostFarmingBoostBoostPoolInfo>, []> & QueryableStorageEntry<ApiType, []>;
            boostVotingPools: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<u128>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            boostWhitelist: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<Null>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            gaugeInfos: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<BifrostFarmingGaugeGaugeInfo>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;
            /**
             * Record gauge farming pool info.
             *
             * map PoolId => GaugePoolInfo
             **/
            gaugePoolInfos: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<BifrostFarmingGaugeGaugePoolInfo>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            gaugePoolNextId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Record reward pool info.
             *
             * map PoolId => PoolInfo
             **/
            poolInfos: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<BifrostFarmingRewardsPoolInfo>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            poolNextId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            retireLimit: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Record share amount, reward currency and withdrawn reward amount for
             * specific `AccountId` under `PoolId`.
             *
             * double_map (PoolId, AccountId) => ShareInfo
             **/
            sharesAndWithdrawnRewards: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<BifrostFarmingRewardsShareInfo>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;
            userBoostInfos: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<BifrostFarmingBoostUserBoostInfo>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        feeShare: {
            autoEra: AugmentedQuery<ApiType, () => Observable<ITuple<[u32, u32]>>, []> & QueryableStorageEntry<ApiType, []>;
            distributionInfos: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<BifrostFeeShareInfo>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            distributionNextId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        flexibleFee: {
            /**
             * Universal fee currency order list for all users
             **/
            universalFeeCurrencyOrderList: AugmentedQuery<ApiType, () => Observable<Vec<NodePrimitivesCurrencyCurrencyId>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * User default fee currency, if set, will be used as the first fee currency, and then use the
             * universal fee currency order list
             **/
            userDefaultFeeCurrency: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<NodePrimitivesCurrencyCurrencyId>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Deprecated. To-be removed after all data deleted.
             **/
            userFeeChargeOrderList: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<Vec<NodePrimitivesCurrencyCurrencyId>>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        identity: {
            /**
             * Information that is pertinent to identify the entity behind an account.
             *
             * TWOX-NOTE: OK ― `AccountId` is a secure hash.
             **/
            identityOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletIdentityRegistration>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * The set of registrars. Not expected to get very big as can only be added through a
             * special origin (likely a council motion).
             *
             * The index into this can be cast to `RegistrarIndex` to get a valid value.
             **/
            registrars: AugmentedQuery<ApiType, () => Observable<Vec<Option<PalletIdentityRegistrarInfo>>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Alternative "sub" identities of this account.
             *
             * The first item is the deposit, the second is a vector of the accounts.
             *
             * TWOX-NOTE: OK ― `AccountId` is a secure hash.
             **/
            subsOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<ITuple<[u128, Vec<AccountId32>]>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * The super-identity of an alternative "sub" identity together with its name, within that
             * context. If the account is not some other account's sub-identity, then just `None`.
             **/
            superOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<ITuple<[AccountId32, Data]>>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        indices: {
            /**
             * The lookup from index to account.
             **/
            accounts: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[AccountId32, u128, bool]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        lighteningRedeem: {
            /**
             * Exchange price discount: vsbond + vstoken => token
             **/
            exchangePriceDiscount: AugmentedQuery<ApiType, () => Observable<Percent>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The remaining amount which can be exchanged for
             **/
            poolAmount: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Token release start block
             **/
            startEndReleaseBlock: AugmentedQuery<ApiType, () => Observable<ITuple<[u32, u32]>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * token amount that is released everyday.
             **/
            tokenReleasePerDay: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        liquidityMining: {
            /**
             * The storage is used to store pool-ids which point to the Pools at `PoolState::Charged`.
             *
             * Actually, the pools(that the storage points to) are pending to be activated by `Hook`;
             * The activation means converting the pools from `PoolState::Charged` to `PoolState::Ongoing`
             * after the conditions that are set at the pool-creation stage are met.
             **/
            chargedPoolIds: AugmentedQuery<ApiType, () => Observable<BTreeSet<u32>>, []> & QueryableStorageEntry<ApiType, []>;
            nextPoolId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            palletVersion: AugmentedQuery<ApiType, () => Observable<BifrostLiquidityMiningStorageVersion>, []> & QueryableStorageEntry<ApiType, []>;
            totalDepositDataV200: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<BifrostLiquidityMiningDepositData>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;
            totalPoolInfosV200: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<BifrostLiquidityMiningPoolInfo>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        liquidityMiningDOT: {
            /**
             * The storage is used to store pool-ids which point to the Pools at `PoolState::Charged`.
             *
             * Actually, the pools(that the storage points to) are pending to be activated by `Hook`;
             * The activation means converting the pools from `PoolState::Charged` to `PoolState::Ongoing`
             * after the conditions that are set at the pool-creation stage are met.
             **/
            chargedPoolIds: AugmentedQuery<ApiType, () => Observable<BTreeSet<u32>>, []> & QueryableStorageEntry<ApiType, []>;
            nextPoolId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            palletVersion: AugmentedQuery<ApiType, () => Observable<BifrostLiquidityMiningStorageVersion>, []> & QueryableStorageEntry<ApiType, []>;
            totalDepositDataV200: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<BifrostLiquidityMiningDepositData>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;
            totalPoolInfosV200: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<BifrostLiquidityMiningPoolInfo>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        merkleDistributor: {
            claimedBitMap: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
            /**
             * Accounts in the whitelist can create merkle distributor.
             **/
            createWhiteSet: AugmentedQuery<ApiType, () => Observable<BTreeSet<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
            merkleDistributorMetadata: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<MerkleDistributorMerkleMetadata>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            nextMerkleDistributorId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        multisig: {
            /**
             * The set of open multisig operations.
             **/
            multisigs: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: U8aFixed | string | Uint8Array) => Observable<Option<PalletMultisigMultisig>>, [AccountId32, U8aFixed]> & QueryableStorageEntry<ApiType, [AccountId32, U8aFixed]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        parachainInfo: {
            parachainId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        parachainStaking: {
            /**
             * Snapshot of collator delegation stake at the start of the round
             **/
            atStake: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<ParachainStakingCollatorSnapshot>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;
            /**
             * Points for each collator per round
             **/
            awardedPts: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<u32>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;
            /**
             * Bottom delegations for collator candidate
             **/
            bottomDelegations: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<ParachainStakingDelegations>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Get collator candidate info associated with an account if account is candidate else None
             **/
            candidateInfo: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<ParachainStakingCandidateMetadata>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * The pool of collator candidates, each with their total backing stake
             **/
            candidatePool: AugmentedQuery<ApiType, () => Observable<Vec<ParachainStakingBond>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Commission percent taken off of rewards for all collators
             **/
            collatorCommission: AugmentedQuery<ApiType, () => Observable<Perbill>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Temporary storage item to track whether a given collator's reserve has been migrated.
             **/
            collatorReserveToLockMigrations: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<bool>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Delayed payouts
             **/
            delayedPayouts: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<ParachainStakingDelayedPayout>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * Stores outstanding delegation requests per collator.
             **/
            delegationScheduledRequests: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<ParachainStakingDelegationRequestsScheduledRequest>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Temporary storage item to track whether a given delegator's reserve has been migrated.
             **/
            delegatorReserveToLockMigrations: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<bool>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Get delegator state associated with an account if account is delegating else None
             **/
            delegatorState: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<ParachainStakingDelegator>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Inflation configuration
             **/
            inflationConfig: AugmentedQuery<ApiType, () => Observable<ParachainStakingInflationInflationInfo>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Parachain bond config info { account, percent_of_inflation }
             **/
            parachainBondInfo: AugmentedQuery<ApiType, () => Observable<ParachainStakingParachainBondConfig>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Total points awarded to collators for block production in the round
             **/
            points: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * Current round index and next round scheduled transition
             **/
            round: AugmentedQuery<ApiType, () => Observable<ParachainStakingRoundInfo>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The collator candidates selected for the current round
             **/
            selectedCandidates: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Total counted stake for selected candidates in the round
             **/
            staked: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * Top delegations for collator candidate
             **/
            topDelegations: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<ParachainStakingDelegations>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Total capital locked by this staking pallet
             **/
            total: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The total candidates selected every round
             **/
            totalSelected: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        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>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The next authorized upgrade, if there is one.
             **/
            authorizedUpgrade: AugmentedQuery<ApiType, () => Observable<Option<H256>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * 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>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Were the validation data set to notify the relay chain?
             **/
            didSetValidationCode: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The parachain host configuration that was obtained from the relay parent.
             *
             * This field is meant to be updated each