import type { Bytes, Option, Vec, bool, u16, u32, u64 } from '@polkadot/types';
import type { AnyNumber, ITuple, Observable } from '@polkadot/types/types';
import type { UncleEntryItem } from '@polkadot/types/interfaces/authorship';
import type { BabeAuthorityWeight, MaybeRandomness, NextConfigDescriptor, Randomness } from '@polkadot/types/interfaces/babe';
import type { BalanceLock } from '@polkadot/types/interfaces/balances';
import type { AuthorityId } from '@polkadot/types/interfaces/consensus';
import type { Proposal } from '@polkadot/types/interfaces/democracy';
import type { Vote } from '@polkadot/types/interfaces/elections';
import type { SetId, StoredPendingChange, StoredState } from '@polkadot/types/interfaces/grandpa';
import type { AuthIndex } from '@polkadot/types/interfaces/imOnline';
import type { DeferredOffenceOf, Kind, OffenceDetails, OpaqueTimeSlot, ReportIdOf } from '@polkadot/types/interfaces/offences';
import type { AccountId, AccountIndex, Balance, BalanceOf, BlockNumber, Call, Hash, KeyTypeId, Moment, Perbill, Releases, Slot, ValidatorId } from '@polkadot/types/interfaces/runtime';
import type { Scheduled, TaskAddress } from '@polkadot/types/interfaces/scheduler';
import type { Keys, SessionIndex } from '@polkadot/types/interfaces/session';
import type { ActiveEraInfo, ElectionResult, ElectionScore, ElectionStatus, EraIndex, EraRewardPoints, Exposure, Forcing, Nominations, RewardDestination, SlashingSpans, SpanIndex, SpanRecord, StakingLedger, UnappliedSlash, ValidatorPrefs } from '@polkadot/types/interfaces/staking';
import type { AccountInfo, ConsumedWeight, DigestOf, EventIndex, EventRecord, LastRuntimeUpgradeInfo, Phase } from '@polkadot/types/interfaces/system';
import type { Multiplier } from '@polkadot/types/interfaces/txpayment';
import type { AGId, AffirmationStatus, AgentGroup, AssetCompliance, AssetIdentifier, AssetName, AssetOwnershipRelation, Authorization, AuthorizationNonce, BallotMeta, BallotTimeRange, BallotVote, BridgeTxDetail, CADetails, CAId, CheckpointId, Claim1stKey, Claim2ndKey, ClassicTickerRegistration, CorporateAction, Counter, CustomAssetTypeId, DepositInfo, DidRecord, Distribution, Document, DocumentId, ExtrinsicPermissions, FundingRoundName, Fundraiser, FundraiserId, FundraiserName, IdentityClaim, IdentityId, InactiveMember, Instruction, InstructionId, ItnRewardStatus, Leg, LegId, LegStatus, LocalCAId, MaybeBlock, PermissionedIdentityPrefs, Pip, PipId, PipsMetadata, PolymeshVotes, PortfolioId, PortfolioName, PortfolioNumber, PosRatio, ProposalDetails, ProtocolOp, ScheduleId, ScopeId, SecurityToken, Signatory, SkippedCount, SlashingSwitch, SnapshotId, SnapshotMetadata, SnapshottedPip, StoredSchedule, Subsidy, TargetIdentities, Tax, Ticker, TickerRegistration, TickerRegistrationConfig, TransferManager, TrustedIssuer, Venue, VenueDetails, VenueId, Version, VotingResult } from "./polymesh";
import type { ApiTypes } from '@polkadot/api/types';
declare module '@polkadot/api/types/storage' {
    interface AugmentedQueries<ApiType> {
        asset: {
            /**
             * Store aggregate balance of those identities that has the same `ScopeId`.
             * (Ticker, ScopeId) => Balance.
             **/
            aggregateBalance: AugmentedQuery<ApiType, (arg1: Ticker | string | Uint8Array, arg2: ScopeId | string | Uint8Array) => Observable<Balance>, [
                Ticker,
                ScopeId
            ]>;
            /**
             * Documents attached to an Asset
             * (ticker, doc_id) -> document
             **/
            assetDocuments: AugmentedQuery<ApiType, (arg1: Ticker | string | Uint8Array, arg2: DocumentId | AnyNumber | Uint8Array) => Observable<Document>, [
                Ticker,
                DocumentId
            ]>;
            /**
             * Per-ticker document ID counter.
             * (ticker) -> doc_id
             **/
            assetDocumentsIdSequence: AugmentedQuery<ApiType, (arg: Ticker | string | Uint8Array) => Observable<DocumentId>, [
                Ticker
            ]>;
            /**
             * Asset name of the token corresponding to the token ticker.
             * (ticker) -> `AssetName`
             **/
            assetNames: AugmentedQuery<ApiType, (arg: Ticker | string | Uint8Array) => Observable<AssetName>, [
                Ticker
            ]>;
            /**
             * Tickers and token owned by a user
             * (user, ticker) -> AssetOwnership
             **/
            assetOwnershipRelations: AugmentedQuery<ApiType, (arg1: IdentityId | string | Uint8Array, arg2: Ticker | string | Uint8Array) => Observable<AssetOwnershipRelation>, [
                IdentityId,
                Ticker
            ]>;
            /**
             * The total asset ticker balance per identity.
             * (ticker, DID) -> Balance
             **/
            balanceOf: AugmentedQuery<ApiType, (arg1: Ticker | string | Uint8Array, arg2: IdentityId | string | Uint8Array) => Observable<Balance>, [
                Ticker,
                IdentityId
            ]>;
            /**
             * Balances get stored on the basis of the `ScopeId`.
             * Right now it is only helpful for the UI purposes but in future it can be used to do miracles on-chain.
             * (ScopeId, IdentityId) => Balance.
             **/
            balanceOfAtScope: AugmentedQuery<ApiType, (arg1: ScopeId | string | Uint8Array, arg2: IdentityId | string | Uint8Array) => Observable<Balance>, [
                ScopeId,
                IdentityId
            ]>;
            /**
             * Ticker registration details on Polymath Classic / Ethereum.
             **/
            classicTickers: AugmentedQuery<ApiType, (arg: Ticker | string | Uint8Array) => Observable<Option<ClassicTickerRegistration>>, [
                Ticker
            ]>;
            /**
             * The next `AssetType::Custom` ID in the sequence.
             *
             * Numbers in the sequence start from 1 rather than 0.
             **/
            customTypeIdSequence: AugmentedQuery<ApiType, () => Observable<CustomAssetTypeId>, []>;
            /**
             * Maps custom asset type ids to the registered string contents.
             **/
            customTypes: AugmentedQuery<ApiType, (arg: CustomAssetTypeId | AnyNumber | Uint8Array) => Observable<Bytes>, [
                CustomAssetTypeId
            ]>;
            /**
             * Inverse map of `CustomTypes`, from registered string contents to custom asset type ids.
             **/
            customTypesInverse: AugmentedQuery<ApiType, (arg: Bytes | string | Uint8Array) => Observable<CustomAssetTypeId>, [
                Bytes
            ]>;
            /**
             * Decides whether investor uniqueness requirement is enforced for this asset.
             * `false` means that it is enforced.
             *
             * Ticker => bool.
             **/
            disableInvestorUniqueness: AugmentedQuery<ApiType, (arg: Ticker | string | Uint8Array) => Observable<bool>, [
                Ticker
            ]>;
            /**
             * The set of frozen assets implemented as a membership map.
             * ticker -> bool
             **/
            frozen: AugmentedQuery<ApiType, (arg: Ticker | string | Uint8Array) => Observable<bool>, [
                Ticker
            ]>;
            /**
             * The name of the current funding round.
             * ticker -> funding round
             **/
            fundingRound: AugmentedQuery<ApiType, (arg: Ticker | string | Uint8Array) => Observable<FundingRoundName>, [
                Ticker
            ]>;
            /**
             * A map of a ticker name and asset identifiers.
             **/
            identifiers: AugmentedQuery<ApiType, (arg: Ticker | string | Uint8Array) => Observable<Vec<AssetIdentifier>>, [
                Ticker
            ]>;
            /**
             * The total balances of tokens issued in all recorded funding rounds.
             * (ticker, funding round) -> balance
             **/
            issuedInFundingRound: AugmentedQuery<ApiType, (arg: ITuple<[Ticker, FundingRoundName]> | [Ticker | string | Uint8Array, FundingRoundName | string]) => Observable<Balance>, [
                ITuple<[Ticker, FundingRoundName]>
            ]>;
            /**
             * Tracks the ScopeId of the identity for a given ticker.
             * (Ticker, IdentityId) => ScopeId.
             **/
            scopeIdOf: AugmentedQuery<ApiType, (arg1: Ticker | string | Uint8Array, arg2: IdentityId | string | Uint8Array) => Observable<ScopeId>, [
                Ticker,
                IdentityId
            ]>;
            /**
             * Storage version.
             **/
            storageVersion: AugmentedQuery<ApiType, () => Observable<Version>, []>;
            /**
             * Ticker registration config.
             * (ticker) -> TickerRegistrationConfig
             **/
            tickerConfig: AugmentedQuery<ApiType, () => Observable<TickerRegistrationConfig>, []>;
            /**
             * Ticker registration details.
             * (ticker) -> TickerRegistration
             **/
            tickers: AugmentedQuery<ApiType, (arg: Ticker | string | Uint8Array) => Observable<TickerRegistration>, [
                Ticker
            ]>;
            /**
             * Details of the token corresponding to the token ticker.
             * (ticker) -> SecurityToken details [returns SecurityToken struct]
             **/
            tokens: AugmentedQuery<ApiType, (arg: Ticker | string | Uint8Array) => Observable<SecurityToken>, [
                Ticker
            ]>;
        };
        authorship: {
            /**
             * Author of current block.
             **/
            author: AugmentedQuery<ApiType, () => Observable<Option<AccountId>>, []>;
            /**
             * Whether uncles were already set in this block.
             **/
            didSetUncles: AugmentedQuery<ApiType, () => Observable<bool>, []>;
            /**
             * Uncles
             **/
            uncles: AugmentedQuery<ApiType, () => Observable<Vec<UncleEntryItem>>, []>;
        };
        babe: {
            /**
             * Current epoch authorities.
             **/
            authorities: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[AuthorityId, BabeAuthorityWeight]>>>, [
            ]>;
            /**
             * Temporary value (cleared at block finalization) that includes the VRF output generated
             * at this block. This field should always be populated during block processing unless
             * secondary plain slots are enabled (which don't contain a VRF output).
             **/
            authorVrfRandomness: AugmentedQuery<ApiType, () => Observable<MaybeRandomness>, []>;
            /**
             * Current slot number.
             **/
            currentSlot: AugmentedQuery<ApiType, () => Observable<Slot>, []>;
            /**
             * Current epoch index.
             **/
            epochIndex: AugmentedQuery<ApiType, () => Observable<u64>, []>;
            /**
             * The slot at which the first epoch actually started. This is 0
             * until the first block of the chain.
             **/
            genesisSlot: AugmentedQuery<ApiType, () => Observable<Slot>, []>;
            /**
             * Temporary value (cleared at block finalization) which is `Some`
             * if per-block initialization has already been called for current block.
             **/
            initialized: AugmentedQuery<ApiType, () => Observable<Option<MaybeRandomness>>, []>;
            /**
             * How late the current block is compared to its parent.
             *
             * This entry is populated as part of block execution and is cleaned up
             * on block finalization. Querying this storage entry outside of block
             * execution context should always yield zero.
             **/
            lateness: AugmentedQuery<ApiType, () => Observable<BlockNumber>, []>;
            /**
             * Next epoch authorities.
             **/
            nextAuthorities: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[AuthorityId, BabeAuthorityWeight]>>>, [
            ]>;
            /**
             * Next epoch configuration, if changed.
             **/
            nextEpochConfig: AugmentedQuery<ApiType, () => Observable<Option<NextConfigDescriptor>>, []>;
            /**
             * Next epoch randomness.
             **/
            nextRandomness: AugmentedQuery<ApiType, () => Observable<Randomness>, []>;
            /**
             * The epoch randomness for the *current* epoch.
             *
             * # Security
             *
             * This MUST NOT be used for gambling, as it can be influenced by a
             * malicious validator in the short term. It MAY be used in many
             * cryptographic protocols, however, so long as one remembers that this
             * (like everything else on-chain) it is public. For example, it can be
             * used where a number is needed that cannot have been chosen by an
             * adversary, for purposes such as public-coin zero-knowledge proofs.
             **/
            randomness: AugmentedQuery<ApiType, () => Observable<Randomness>, []>;
            /**
             * Randomness under construction.
             *
             * We make a tradeoff between storage accesses and list length.
             * We store the under-construction randomness in segments of up to
             * `UNDER_CONSTRUCTION_SEGMENT_LENGTH`.
             *
             * Once a segment reaches this length, we begin the next one.
             * We reset all segments and return to `0` at the beginning of every
             * epoch.
             **/
            segmentIndex: AugmentedQuery<ApiType, () => Observable<u32>, []>;
            /**
             * TWOX-NOTE: `SegmentIndex` is an increasing integer, so this is okay.
             **/
            underConstruction: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<Randomness>>, [
                u32
            ]>;
        };
        balances: {
            /**
             * Any liquidity locks on some account balances.
             * NOTE: Should only be accessed when setting, changing and freeing a lock.
             **/
            locks: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Vec<BalanceLock>>, [
                AccountId
            ]>;
            /**
             * The total units issued in the system.
             **/
            totalIssuance: AugmentedQuery<ApiType, () => Observable<Balance>, []>;
        };
        bridge: {
            /**
             * The admin key.
             **/
            admin: AugmentedQuery<ApiType, () => Observable<AccountId>, []>;
            /**
             * The maximum number of bridged POLYX per identity within a set interval of
             * blocks. Fields: POLYX amount and the block interval duration.
             **/
            bridgeLimit: AugmentedQuery<ApiType, () => Observable<ITuple<[Balance, BlockNumber]>>, []>;
            /**
             * Identities not constrained by the bridge limit.
             **/
            bridgeLimitExempted: AugmentedQuery<ApiType, (arg: IdentityId | string | Uint8Array) => Observable<bool>, [
                IdentityId
            ]>;
            /**
             * Details of bridge transactions identified with pairs of the recipient account and the
             * bridge transaction nonce.
             **/
            bridgeTxDetails: AugmentedQuery<ApiType, (arg1: AccountId | string | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<BridgeTxDetail>, [
                AccountId,
                u32
            ]>;
            /**
             * The multisig account of the bridge controller. The genesis signers accept their
             * authorizations and are able to get their proposals delivered. The bridge creator
             * transfers some POLY to their identity.
             **/
            controller: AugmentedQuery<ApiType, () => Observable<AccountId>, []>;
            /**
             * Freeze bridge admins.  These accounts can only freeze the bridge.
             **/
            freezeAdmins: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<bool>, [
                AccountId
            ]>;
            /**
             * Whether or not the bridge operation is frozen.
             **/
            frozen: AugmentedQuery<ApiType, () => Observable<bool>, []>;
            /**
             * Amount of POLYX bridged by the identity in last block interval. Fields: the bridged
             * amount and the last interval number.
             **/
            polyxBridged: AugmentedQuery<ApiType, (arg: IdentityId | string | Uint8Array) => Observable<ITuple<[Balance, BlockNumber]>>, [
                IdentityId
            ]>;
            /**
             * Storage version.
             **/
            storageVersion: AugmentedQuery<ApiType, () => Observable<Version>, []>;
            /**
             * The bridge transaction timelock period, in blocks, since the acceptance of the
             * transaction proposal during which the admin key can freeze the transaction.
             **/
            timelock: AugmentedQuery<ApiType, () => Observable<BlockNumber>, []>;
        };
        capitalDistribution: {
            /**
             * All capital distributions, tied to their respective corporate actions (CAs).
             *
             * (CAId) => Distribution
             **/
            distributions: AugmentedQuery<ApiType, (arg: CAId | {
                ticker?: any;
                local_id?: any;
            } | string | Uint8Array) => Observable<Option<Distribution>>, [
                CAId
            ]>;
            /**
             * Has an asset holder been paid yet?
             *
             * (CAId, DID) -> Was DID paid in the CAId?
             **/
            holderPaid: AugmentedQuery<ApiType, (arg: ITuple<[CAId, IdentityId]> | [
                CAId | {
                    ticker?: any;
                    local_id?: any;
                } | string | Uint8Array,
                IdentityId | string | Uint8Array
            ]) => Observable<bool>, [
                ITuple<[CAId, IdentityId]>
            ]>;
            /**
             * Storage version.
             **/
            storageVersion: AugmentedQuery<ApiType, () => Observable<Version>, []>;
        };
        cddServiceProviders: {
            /**
             * The current "active" membership, stored as an ordered Vec.
             **/
            activeMembers: AugmentedQuery<ApiType, () => Observable<Vec<IdentityId>>, []>;
            /**
             * Limit of how many "active" members there can be.
             **/
            activeMembersLimit: AugmentedQuery<ApiType, () => Observable<u32>, []>;
            /**
             * The current "inactive" membership, stored as an ordered Vec.
             **/
            inactiveMembers: AugmentedQuery<ApiType, () => Observable<Vec<InactiveMember>>, []>;
        };
        checkpoint: {
            /**
             * Balance of a DID at a checkpoint.
             *
             * (ticker, did, checkpoint ID) -> Balance of a DID at a checkpoint
             **/
            balance: AugmentedQuery<ApiType, (arg1: ITuple<[Ticker, CheckpointId]> | [Ticker | string | Uint8Array, CheckpointId | AnyNumber | Uint8Array], arg2: IdentityId | string | Uint8Array) => Observable<Balance>, [
                ITuple<[Ticker, CheckpointId]>,
                IdentityId
            ]>;
            /**
             * Checkpoints where a DID's balance was updated.
             * (ticker, did) -> [checkpoint ID where user balance changed]
             **/
            balanceUpdates: AugmentedQuery<ApiType, (arg1: Ticker | string | Uint8Array, arg2: IdentityId | string | Uint8Array) => Observable<Vec<CheckpointId>>, [
                Ticker,
                IdentityId
            ]>;
            /**
             * Checkpoints ID generator sequence.
             * ID of first checkpoint is 1 instead of 0.
             *
             * (ticker) -> no. of checkpoints
             **/
            checkpointIdSequence: AugmentedQuery<ApiType, (arg: Ticker | string | Uint8Array) => Observable<CheckpointId>, [
                Ticker
            ]>;
            /**
             * Checkpoint schedule ID sequence for tickers.
             *
             * (ticker) -> schedule ID
             **/
            scheduleIdSequence: AugmentedQuery<ApiType, (arg: Ticker | string | Uint8Array) => Observable<ScheduleId>, [
                Ticker
            ]>;
            /**
             * All the checkpoints a given schedule originated.
             *
             * (ticker, schedule ID) -> [checkpoint ID]
             **/
            schedulePoints: AugmentedQuery<ApiType, (arg1: Ticker | string | Uint8Array, arg2: ScheduleId | AnyNumber | Uint8Array) => Observable<Vec<CheckpointId>>, [
                Ticker,
                ScheduleId
            ]>;
            /**
             * How many "strong" references are there to a given `ScheduleId`?
             *
             * The presence of a "strong" reference, in the sense of `Rc<T>`,
             * entails that the referenced schedule cannot be removed.
             * Thus, as long as `strong_ref_count(schedule_id) > 0`,
             * `remove_schedule(schedule_id)` will error.
             *
             * (ticker, schedule ID) -> strong ref count
             **/
            scheduleRefCount: AugmentedQuery<ApiType, (arg1: Ticker | string | Uint8Array, arg2: ScheduleId | AnyNumber | Uint8Array) => Observable<u32>, [
                Ticker,
                ScheduleId
            ]>;
            /**
             * Checkpoint schedules for tickers.
             *
             * (ticker) -> [schedule]
             **/
            schedules: AugmentedQuery<ApiType, (arg: Ticker | string | Uint8Array) => Observable<Vec<StoredSchedule>>, [
                Ticker
            ]>;
            /**
             * The maximum complexity allowed for an arbitrary ticker's schedule set
             * (i.e. `Schedules` storage item below).
             **/
            schedulesMaxComplexity: AugmentedQuery<ApiType, () => Observable<u64>, []>;
            /**
             * Storage version.
             **/
            storageVersion: AugmentedQuery<ApiType, () => Observable<Version>, []>;
            /**
             * Checkpoint timestamps.
             *
             * Every schedule-originated checkpoint maps its ID to its due time.
             * Every checkpoint manually created maps its ID to the time of recording.
             *
             * (ticker) -> (checkpoint ID) -> checkpoint timestamp
             **/
            timestamps: AugmentedQuery<ApiType, (arg1: Ticker | string | Uint8Array, arg2: CheckpointId | AnyNumber | Uint8Array) => Observable<Moment>, [
                Ticker,
                CheckpointId
            ]>;
            /**
             * Total supply of the token at the checkpoint.
             *
             * (ticker, checkpointId) -> total supply at given checkpoint
             **/
            totalSupply: AugmentedQuery<ApiType, (arg1: Ticker | string | Uint8Array, arg2: CheckpointId | AnyNumber | Uint8Array) => Observable<Balance>, [
                Ticker,
                CheckpointId
            ]>;
        };
        committeeMembership: {
            /**
             * The current "active" membership, stored as an ordered Vec.
             **/
            activeMembers: AugmentedQuery<ApiType, () => Observable<Vec<IdentityId>>, []>;
            /**
             * Limit of how many "active" members there can be.
             **/
            activeMembersLimit: AugmentedQuery<ApiType, () => Observable<u32>, []>;
            /**
             * The current "inactive" membership, stored as an ordered Vec.
             **/
            inactiveMembers: AugmentedQuery<ApiType, () => Observable<Vec<InactiveMember>>, []>;
        };
        complianceManager: {
            /**
             * Asset compliance for a ticker (Ticker -> AssetCompliance)
             **/
            assetCompliances: AugmentedQuery<ApiType, (arg: Ticker | string | Uint8Array) => Observable<AssetCompliance>, [
                Ticker
            ]>;
            /**
             * Storage version.
             **/
            storageVersion: AugmentedQuery<ApiType, () => Observable<Version>, []>;
            /**
             * List of trusted claim issuer Ticker -> Issuer Identity
             **/
            trustedClaimIssuer: AugmentedQuery<ApiType, (arg: Ticker | string | Uint8Array) => Observable<Vec<TrustedIssuer>>, [
                Ticker
            ]>;
        };
        corporateAction: {
            /**
             * Associations from CAs to `Document`s via their IDs.
             * (CAId => [DocumentId])
             *
             * The `CorporateActions` map stores `Ticker => LocalId => The CA`,
             * so we can infer `Ticker => CAId`. Therefore, we don't need a double map.
             **/
            cADocLink: AugmentedQuery<ApiType, (arg: CAId | {
                ticker?: any;
                local_id?: any;
            } | string | Uint8Array) => Observable<Vec<DocumentId>>, [
                CAId
            ]>;
            /**
             * The next per-`Ticker` CA ID in the sequence.
             * The full ID is defined as a combination of `Ticker` and a number in this sequence.
             **/
            cAIdSequence: AugmentedQuery<ApiType, (arg: Ticker | string | Uint8Array) => Observable<LocalCAId>, [
                Ticker
            ]>;
            /**
             * All recorded CAs thus far.
             * Only generic information is stored here.
             * Specific `CAKind`s, e.g., benefits and corporate ballots, may use additional on-chain storage.
             *
             * (ticker => local ID => the corporate action)
             **/
            corporateActions: AugmentedQuery<ApiType, (arg1: Ticker | string | Uint8Array, arg2: LocalCAId | AnyNumber | Uint8Array) => Observable<Option<CorporateAction>>, [
                Ticker,
                LocalCAId
            ]>;
            /**
             * The identities targeted by default for CAs for this ticker,
             * either to be excluded or included.
             *
             * (ticker => target identities)
             **/
            defaultTargetIdentities: AugmentedQuery<ApiType, (arg: Ticker | string | Uint8Array) => Observable<TargetIdentities>, [
                Ticker
            ]>;
            /**
             * The default amount of tax to withhold ("withholding tax", WT) for this ticker when distributing dividends.
             *
             * To understand withholding tax, e.g., let's assume that you hold ACME shares.
             * ACME now decides to distribute 100 SEK to Alice.
             * Alice lives in Sweden, so Skatteverket (the Swedish tax authority) wants 30% of that.
             * Then those 100 * 30% are withheld from Alice, and ACME will send them to Skatteverket.
             *
             * (ticker => % to withhold)
             **/
            defaultWithholdingTax: AugmentedQuery<ApiType, (arg: Ticker | string | Uint8Array) => Observable<Tax>, [
                Ticker
            ]>;
            /**
             * Associates details in free-form text with a CA by its ID.
             * (CAId => CADetails)
             **/
            details: AugmentedQuery<ApiType, (arg: CAId | {
                ticker?: any;
                local_id?: any;
            } | string | Uint8Array) => Observable<CADetails>, [
                CAId
            ]>;
            /**
             * The amount of tax to withhold ("withholding tax", WT) for a certain ticker x DID.
             * If an entry exists for a certain DID, it overrides the default in `DefaultWithholdingTax`.
             *
             * (ticker => [(did, % to withhold)]
             **/
            didWithholdingTax: AugmentedQuery<ApiType, (arg: Ticker | string | Uint8Array) => Observable<Vec<ITuple<[IdentityId, Tax]>>>, [
                Ticker
            ]>;
            /**
             * Determines the maximum number of bytes that the free-form `details` of a CA can store.
             *
             * Note that this is not the number of `char`s or the number of [graphemes].
             * While this may be unnatural in terms of human understanding of a text's length,
             * it more closely reflects actual storage costs (`'a'` is cheaper to store than an emoji).
             *
             * [graphemes]: https://en.wikipedia.org/wiki/Grapheme
             **/
            maxDetailsLength: AugmentedQuery<ApiType, () => Observable<u32>, []>;
            /**
             * Storage version.
             **/
            storageVersion: AugmentedQuery<ApiType, () => Observable<Version>, []>;
        };
        corporateBallot: {
            /**
             * Metadata of a corporate ballot.
             *
             * (CAId) => BallotMeta
             **/
            metas: AugmentedQuery<ApiType, (arg: CAId | {
                ticker?: any;
                local_id?: any;
            } | string | Uint8Array) => Observable<Option<BallotMeta>>, [
                CAId
            ]>;
            /**
             * Stores how many choices there are in each motion.
             *
             * At all times, the invariant holds that `motion_choices[idx]` is equal to
             * `metas.unwrap().motions[idx].choices.len()`. That is, this is just a cache,
             * used to avoid fetching all the motions with their associated texts.
             *
             * `u16` choices should be more than enough to fit real use cases.
             *
             * (CAId) => Number of choices in each motion.
             **/
            motionNumChoices: AugmentedQuery<ApiType, (arg: CAId | {
                ticker?: any;
                local_id?: any;
            } | string | Uint8Array) => Observable<Vec<u16>>, [
                CAId
            ]>;
            /**
             * Is ranked choice voting (RCV) enabled for this ballot?
             * For an understanding of how RCV is handled, see note on `BallotVote`'s `fallback` field.
             *
             * (CAId) => bool
             **/
            rcv: AugmentedQuery<ApiType, (arg: CAId | {
                ticker?: any;
                local_id?: any;
            } | string | Uint8Array) => Observable<bool>, [
                CAId
            ]>;
            /**
             * Stores the total vote tally on each choice.
             *
             * RCV is not accounted for,
             * as there are too many wants to interpret the graph,
             * and because it would not be efficient.
             *
             * (CAId) => [current vote weights]
             **/
            results: AugmentedQuery<ApiType, (arg: CAId | {
                ticker?: any;
                local_id?: any;
            } | string | Uint8Array) => Observable<Vec<Balance>>, [
                CAId
            ]>;
            /**
             * Time details of a corporate ballot associated with a CA.
             * The timestamps denote when voting starts and stops.
             *
             * (CAId) => BallotTimeRange
             **/
            timeRanges: AugmentedQuery<ApiType, (arg: CAId | {
                ticker?: any;
                local_id?: any;
            } | string | Uint8Array) => Observable<Option<BallotTimeRange>>, [
                CAId
            ]>;
            /**
             * Stores each DID's votes in a given ballot.
             * See the documentation of `BallotVote` for notes on semantics.
             *
             * (CAId) => (DID) => [vote weight]
             *
             * User must enter 0 vote weight if they don't want to vote for a choice.
             **/
            votes: AugmentedQuery<ApiType, (arg1: CAId | {
                ticker?: any;
                local_id?: any;
            } | string | Uint8Array, arg2: IdentityId | string | Uint8Array) => Observable<Vec<BallotVote>>, [
                CAId,
                IdentityId
            ]>;
        };
        externalAgents: {
            /**
             * Maps an agent (`IdentityId`) to all all `Ticker`s they belong to, if any.
             **/
            agentOf: AugmentedQuery<ApiType, (arg1: IdentityId | string | Uint8Array, arg2: Ticker | string | Uint8Array) => Observable<ITuple<[]>>, [
                IdentityId,
                Ticker
            ]>;
            /**
             * The next per-`Ticker` AG ID in the sequence.
             *
             * The full ID is defined as a combination of `Ticker` and a number in this sequence,
             * which starts from 1, rather than 0.
             **/
            aGIdSequence: AugmentedQuery<ApiType, (arg: Ticker | string | Uint8Array) => Observable<AGId>, [
                Ticker
            ]>;
            /**
             * Maps agents (`IdentityId`) for a `Ticker` to what AG they belong to, if any.
             **/
            groupOfAgent: AugmentedQuery<ApiType, (arg1: Ticker | string | Uint8Array, arg2: IdentityId | string | Uint8Array) => Observable<Option<AgentGroup>>, [
                Ticker,
                IdentityId
            ]>;
            /**
             * For custom AGs of a `Ticker`, maps to what permissions an agent in that AG would have.
             **/
            groupPermissions: AugmentedQuery<ApiType, (arg1: Ticker | string | Uint8Array, arg2: AGId | AnyNumber | Uint8Array) => Observable<Option<ExtrinsicPermissions>>, [
                Ticker,
                AGId
            ]>;
            /**
             * Maps a `Ticker` to the number of `Full` agents for it.
             **/
            numFullAgents: AugmentedQuery<ApiType, (arg: Ticker | string | Uint8Array) => Observable<u32>, [
                Ticker
            ]>;
        };
        grandpa: {
            /**
             * The number of changes (both in terms of keys and underlying economic responsibilities)
             * in the "set" of Grandpa validators from genesis.
             **/
            currentSetId: AugmentedQuery<ApiType, () => Observable<SetId>, []>;
            /**
             * next block number where we can force a change.
             **/
            nextForced: AugmentedQuery<ApiType, () => Observable<Option<BlockNumber>>, []>;
            /**
             * Pending change: (signaled at, scheduled change).
             **/
            pendingChange: AugmentedQuery<ApiType, () => Observable<Option<StoredPendingChange>>, []>;
            /**
             * A mapping from grandpa set ID to the index of the *most recent* session for which its
             * members were responsible.
             *
             * TWOX-NOTE: `SetId` is not under user control.
             **/
            setIdSession: AugmentedQuery<ApiType, (arg: SetId | AnyNumber | Uint8Array) => Observable<Option<SessionIndex>>, [
                SetId
            ]>;
            /**
             * `true` if we are currently stalled.
             **/
            stalled: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[BlockNumber, BlockNumber]>>>, [
            ]>;
            /**
             * State of the current authority set.
             **/
            state: AugmentedQuery<ApiType, () => Observable<StoredState>, []>;
        };
        identity: {
            /**
             * How many "strong" references to the account key.
             *
             * Strong references will block a key from leaving it's identity.
             *
             * Pallets using "strong" references to account keys:
             * * Relayer: For `user_key` and `paying_key`
             *
             **/
            accountKeyRefCount: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<u64>, [
                AccountId
            ]>;
            /**
             * All authorizations that an identity/key has
             **/
            authorizations: AugmentedQuery<ApiType, (arg1: Signatory | {
                Identity: any;
            } | {
                Account: any;
            } | string | Uint8Array, arg2: u64 | AnyNumber | Uint8Array) => Observable<Option<Authorization>>, [
                Signatory,
                u64
            ]>;
            /**
             * All authorizations that an identity has given. (Authorizer, auth_id -> authorized)
             **/
            authorizationsGiven: AugmentedQuery<ApiType, (arg1: IdentityId | string | Uint8Array, arg2: u64 | AnyNumber | Uint8Array) => Observable<Signatory>, [
                IdentityId,
                u64
            ]>;
            /**
             * Obsoleted storage variable superceded by `CddAuthForPrimaryKeyRotation`. It is kept here
             * for the purpose of storage migration.
             **/
            cddAuthForMasterKeyRotation: AugmentedQuery<ApiType, () => Observable<bool>, []>;
            /**
             * A config flag that, if set, instructs an authorization from a CDD provider in order to
             * change the primary key of an identity.
             **/
            cddAuthForPrimaryKeyRotation: AugmentedQuery<ApiType, () => Observable<bool>, []>;
            /**
             * (Target ID, claim type) (issuer,scope) -> Associated claims
             **/
            claims: AugmentedQuery<ApiType, (arg1: Claim1stKey | {
                target?: any;
                claim_type?: any;
            } | string | Uint8Array, arg2: Claim2ndKey | {
                issuer?: any;
                scope?: any;
            } | string | Uint8Array) => Observable<IdentityClaim>, [
                Claim1stKey,
                Claim2ndKey
            ]>;
            /**
             * It stores the current identity for current transaction.
             **/
            currentDid: AugmentedQuery<ApiType, () => Observable<Option<IdentityId>>, []>;
            /**
             * It stores the current gas fee payer for the current transaction
             **/
            currentPayer: AugmentedQuery<ApiType, () => Observable<Option<AccountId>>, []>;
            /**
             * DID -> identity info
             **/
            didRecords: AugmentedQuery<ApiType, (arg: IdentityId | string | Uint8Array) => Observable<DidRecord>, [
                IdentityId
            ]>;
            /**
             * DID -> bool that indicates if secondary keys are frozen.
             **/
            isDidFrozen: AugmentedQuery<ApiType, (arg: IdentityId | string | Uint8Array) => Observable<bool>, [
                IdentityId
            ]>;
            keyToIdentityIds: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<IdentityId>, [
                AccountId
            ]>;
            /**
             * Nonce to ensure unique actions. starts from 1.
             **/
            multiPurposeNonce: AugmentedQuery<ApiType, () => Observable<u64>, []>;
            /**
             * Authorization nonce per Identity. Initially is 0.
             **/
            offChainAuthorizationNonce: AugmentedQuery<ApiType, (arg: IdentityId | string | Uint8Array) => Observable<AuthorizationNonce>, [
                IdentityId
            ]>;
            /**
             * Storage version.
             **/
            storageVersion: AugmentedQuery<ApiType, () => Observable<Version>, []>;
        };
        imOnline: {
            /**
             * For each session index, we keep a mapping of `ValidatorId<T>` to the
             * number of blocks authored by the given authority.
             **/
            authoredBlocks: AugmentedQuery<ApiType, (arg1: SessionIndex | AnyNumber | Uint8Array, arg2: ValidatorId | string | Uint8Array) => Observable<u32>, [
                SessionIndex,
                ValidatorId
            ]>;
            /**
             * The block number after which it's ok to send heartbeats in current session.
             *
             * At the beginning of each session we set this to a value that should
             * fall roughly in the middle of the session duration.
             * The idea is to first wait for the validators to produce a block
             * in the current session, so that the heartbeat later on will not be necessary.
             **/
            heartbeatAfter: AugmentedQuery<ApiType, () => Observable<BlockNumber>, []>;
            /**
             * The current set of keys that may issue a heartbeat.
             **/
            keys: AugmentedQuery<ApiType, () => Observable<Vec<AuthorityId>>, []>;
            /**
             * For each session index, we keep a mapping of `AuthIndex` to
             * `offchain::OpaqueNetworkState`.
             **/
            receivedHeartbeats: AugmentedQuery<ApiType, (arg1: SessionIndex | AnyNumber | Uint8Array, arg2: AuthIndex | AnyNumber | Uint8Array) => Observable<Option<Bytes>>, [
                SessionIndex,
                AuthIndex
            ]>;
        };
        indices: {
            /**
             * The lookup from index to account.
             **/
            accounts: AugmentedQuery<ApiType, (arg: AccountIndex | AnyNumber | Uint8Array) => Observable<Option<ITuple<[AccountId, BalanceOf, bool]>>>, [
                AccountIndex
            ]>;
        };
        multiSig: {
            /**
             * Maps a multisig signer key to a multisig address.
             **/
            keyToMultiSig: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<AccountId>, [
                AccountId
            ]>;
            /**
             * Nonce to ensure unique MultiSig addresses are generated; starts from 1.
             **/
            multiSigNonce: AugmentedQuery<ApiType, () => Observable<u64>, []>;
            /**
             * Signers of a multisig. (multisig, signer) => signer.
             **/
            multiSigSigners: AugmentedQuery<ApiType, (arg1: AccountId | string | Uint8Array, arg2: Signatory | {
                Identity: any;
            } | {
                Account: any;
            } | string | Uint8Array) => Observable<Signatory>, [
                AccountId,
                Signatory
            ]>;
            /**
             * Confirmations required before processing a multisig tx.
             **/
            multiSigSignsRequired: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<u64>, [
                AccountId
            ]>;
            /**
             * Maps a multisig account to its identity.
             **/
            multiSigToIdentity: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<IdentityId>, [
                AccountId
            ]>;
            /**
             * Number of transactions proposed in a multisig. Used as tx id; starts from 0.
             **/
            multiSigTxDone: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<u64>, [
                AccountId
            ]>;
            /**
             * Number of approved/accepted signers of a multisig.
             **/
            numberOfSigners: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<u64>, [
                AccountId
            ]>;
            /**
             * Details of a multisig proposal
             **/
            proposalDetail: AugmentedQuery<ApiType, (arg: ITuple<[AccountId, u64]> | [AccountId | string | Uint8Array, u64 | AnyNumber | Uint8Array]) => Observable<ProposalDetails>, [
                ITuple<[AccountId, u64]>
            ]>;
            /**
             * A mapping of proposals to their IDs.
             **/
            proposalIds: AugmentedQuery<ApiType, (arg1: AccountId | string | Uint8Array, arg2: Proposal | {
                callIndex?: any;
                args?: any;
            } | string | Uint8Array) => Observable<Option<u64>>, [
                AccountId,
                Proposal
            ]>;
            /**
             * Proposals presented for voting to a multisig (multisig, proposal id) => Option<T::Proposal>.
             **/
            proposals: AugmentedQuery<ApiType, (arg: ITuple<[AccountId, u64]> | [AccountId | string | Uint8Array, u64 | AnyNumber | Uint8Array]) => Observable<Option<Proposal>>, [
                ITuple<[AccountId, u64]>
            ]>;
            /**
             * The last transaction version, used for `on_runtime_upgrade`.
             **/
            transactionVersion: AugmentedQuery<ApiType, () => Observable<u32>, []>;
            /**
             * Individual multisig signer votes. (multi sig, signer, proposal) => vote.
             **/
            votes: AugmentedQuery<ApiType, (arg: ITuple<[AccountId, Signatory, u64]> | [
                AccountId | string | Uint8Array,
                Signatory | {
                    Identity: any;
                } | {
                    Account: any;
                } | string | Uint8Array,
                u64 | AnyNumber | Uint8Array
            ]) => Observable<bool>, [
                ITuple<[AccountId, Signatory, u64]>
            ]>;
        };
        offences: {
            /**
             * A vector of reports of the same kind that happened at the same time slot.
             **/
            concurrentReportsIndex: AugmentedQuery<ApiType, (arg1: Kind | string | Uint8Array, arg2: OpaqueTimeSlot | string | Uint8Array) => Observable<Vec<ReportIdOf>>, [
                Kind,
                OpaqueTimeSlot
            ]>;
            /**
             * Deferred reports that have been rejected by the offence handler and need to be submitted
             * at a later time.
             **/
            deferredOffences: AugmentedQuery<ApiType, () => Observable<Vec<DeferredOffenceOf>>, []>;
            /**
             * The primary structure that holds all offence records keyed by report identifiers.
             **/
            reports: AugmentedQuery<ApiType, (arg: ReportIdOf | string | Uint8Array) => Observable<Option<OffenceDetails>>, [
                ReportIdOf
            ]>;
            /**
             * Enumerates all reports of a kind along with the time they happened.
             *
             * All reports are sorted by the time of offence.
             *
             * Note that the actual type of this mapping is `Vec<u8>`, this is because values of
             * different types are not supported at the moment so we are doing the manual serialization.
             **/
            reportsByKindIndex: AugmentedQuery<ApiType, (arg: Kind | string | Uint8Array) => Observable<Bytes>, [
                Kind
            ]>;
        };
        pips: {
            /**
             * Total count of current pending or scheduled PIPs.
             **/
            activePipCount: AugmentedQuery<ApiType, () => Observable<u32>, []>;
            /**
             * The maximum allowed number for `ActivePipCount`.
             * Once reached, new PIPs cannot be proposed by community members.
             **/
            activePipLimit: AugmentedQuery<ApiType, () => Observable<u32>, []>;
            /**
             * All existing PIPs where the proposer is a committee.
             * This list is a cache of all ids in `Proposals` with `Proposer::Committee(_)`.
             **/
            committeePips: AugmentedQuery<ApiType, () => Observable<Vec<PipId>>, []>;
            /**
             * Default enactment period that will be use after a proposal is accepted by GC.
             **/
            defaultEnactmentPeriod: AugmentedQuery<ApiType, () => Observable<BlockNumber>, []>;
            /**
             * Those who have locked a deposit.
             * proposal (id, proposer) -> deposit
             **/
            deposits: AugmentedQuery<ApiType, (arg1: PipId | AnyNumber | Uint8Array, arg2: AccountId | string | Uint8Array) => Observable<DepositInfo>, [
                PipId,
                AccountId
            ]>;
            /**
             * A live priority queue (lowest priority at index 0)
             * of pending PIPs up to the active limit.
             * Priority is defined by the `weight` in the `SnapshottedPip`.
             *
             * Unlike `SnapshotQueue`, this queue is live, getting updated with each vote cast.
             * The snapshot is therefore essentially a point-in-time clone of this queue.
             **/
            liveQueue: AugmentedQuery<ApiType, () => Observable<Vec<SnapshottedPip>>, []>;
            /**
             * Maximum times a PIP can be skipped before triggering `CannotSkipPip` in `enact_snapshot_results`.
             **/
            maxPipSkipCount: AugmentedQuery<ApiType, () => Observable<SkippedCount>, []>;
            /**
             * The minimum amount to be used as a deposit for community PIP creation.
             **/
            minimumProposalDeposit: AugmentedQuery<ApiType, () => Observable<Balance>, []>;
            /**
             * How many blocks will it take, after a `Pending` PIP expires,
             * assuming it has not transitioned to another `ProposalState`?
             **/
            pendingPipExpiry: AugmentedQuery<ApiType, () => Observable<MaybeBlock>, []>;
            /**
             * Proposals so far. id can be used to keep track of PIPs off-chain.
             **/
            pipIdSequence: AugmentedQuery<ApiType, () => Observable<PipId>, []>;
            /**
             * The number of times a certain PIP has been skipped.
             * Once a (configurable) threshhold is exceeded, a PIP cannot be skipped again.
             **/
            pipSkipCount: AugmentedQuery<ApiType, (arg: PipId | AnyNumber | Uint8Array) => Observable<SkippedCount>, [
                PipId
            ]>;
            /**
             * Maps PIPs to the block at which they will be executed, if any.
             **/
            pipToSchedule: AugmentedQuery<ApiType, (arg: PipId | AnyNumber | Uint8Array) => Observable<Option<BlockNumber>>, [
                PipId
            ]>;
            /**
             * The metadata of the active proposals.
             **/
            proposalMetadata: AugmentedQuery<ApiType, (arg: PipId | AnyNumber | Uint8Array) => Observable<Option<PipsMetadata>>, [
                PipId
            ]>;
            /**
             * PolymeshVotes on a given proposal, if it is ongoing.
             * proposal id -> vote count
             **/
            proposalResult: AugmentedQuery<ApiType, (arg: PipId | AnyNumber | Uint8Array) => Observable<VotingResult>, [
                PipId
            ]>;
            /**
             * Actual proposal for a given id, if it's current.
             * proposal id -> proposal
             **/
            proposals: AugmentedQuery<ApiType, (arg: PipId | AnyNumber | Uint8Array) => Observable<Option<Pip>>, [
                PipId
            ]>;
            /**
             * Votes per Proposal and account. Used to avoid double vote issue.
             * (proposal id, account) -> Vote
             **/
            proposalVotes: AugmentedQuery<ApiType, (arg1: PipId | AnyNumber | Uint8Array, arg2: AccountId | string | Uint8Array) => Observable<Option<Vote>>, [
                PipId,
                AccountId
            ]>;
            /**
             * Determines whether historical PIP data is persisted or removed
             **/
            pruneHistoricalPips: AugmentedQuery<ApiType, () => Observable<bool>, []>;
            /**
             * Snapshots so far. id can be used to keep track of snapshots off-chain.
             **/
            snapshotIdSequence: AugmentedQuery<ApiType, () => Observable<SnapshotId>, []>;
            /**
             * The metadata of the snapshot, if there is one.
             **/
            snapshotMeta: AugmentedQuery<ApiType, () => Observable<Option<SnapshotMetadata>>, []>;
            /**
             * The priority queue (lowest priority at index 0) of PIPs at the point of snapshotting.
             * Priority is defined by the `weight` in the `SnapshottedPip`.
             *
             * A queued PIP can be skipped. Doing so bumps the `pip_skip_count`.
             * Once a (configurable) threshhold is exceeded, a PIP cannot be skipped again.
             **/
            snapshotQueue: AugmentedQuery<ApiType, () => Observable<Vec<SnapshottedPip>>, []>;
            storageVersion: AugmentedQuery<ApiType, () => Observable<Version>, []>;
        };
        polymeshCommittee: {
            /**
             * Time after which a proposal will expire.
             **/
            expiresAfter: AugmentedQuery<ApiType, () => Observable<MaybeBlock>, []>;
            /**
             * The current members of the committee.
             **/
            members: AugmentedQuery<ApiType, () => Observable<Vec<IdentityId>>, []>;
            /**
             * Proposals so far.
             **/
            proposalCount: AugmentedQuery<ApiType, () => Observable<u32>, []>;
            /**
             * Actual proposal for a given hash.
             **/
            proposalOf: AugmentedQuery<ApiType, (arg: Hash | string | Uint8Array) => Observable<Option<Call>>, [
                Hash
            ]>;
            /**
             * The hashes of the active proposals.
             **/
            proposals: AugmentedQuery<ApiType, () => Observable<Vec<Hash>>, []>;
            /**
             * Release coordinator.
             **/
            releaseCoordinator: AugmentedQuery<ApiType, () => Observable<Option<IdentityId>>, []>;
            /**
             * Storage version.
             **/
            storageVersion: AugmentedQuery<ApiType, () => Observable<Version>, []>;
            /**
             * Vote threshold for an approval.
             **/
            voteThreshold: AugmentedQuery<ApiType, () => Observable<ITuple<[u32, u32]>>, []>;
            /**
             * PolymeshVotes on a given proposal, if it is ongoing.
             **/
            voting: AugmentedQuery<ApiType, (arg: Hash | string | Uint8Array) => Observable<Option<PolymeshVotes>>, [
                Hash
            ]>;
        };
        portfolio: {
            /**
             * Inverse map of `Portfolios` used to ensure bijectivitiy,
             * and uniqueness of names in `Portfolios`.
             **/
            nameToNumber: AugmentedQuery<ApiType, (arg1: IdentityId | string | Uint8Array, arg2: PortfolioName | string) => Observable<PortfolioNumber>, [
                IdentityId,
                PortfolioName
            ]>;
            /**
             * The next portfolio sequence number of an identity.
             **/
            nextPortfolioNumber: AugmentedQuery<ApiType, (arg: IdentityId | string | Uint8Array) => Observable<PortfolioNumber>, [
                IdentityId
            ]>;
            /**
             * The asset balances of portfolios.
             **/
            portfolioAssetBalances: AugmentedQuery<ApiType, (arg1: PortfolioId | {
                did?: any;
                kind?: any;
            } | string | Uint8Array, arg2: Ticker | string | Uint8Array) => Observable<Balance>, [
                PortfolioId,
                Ticker
            ]>;
            /**
             * How many assets with non-zero balance this portfolio contains.
             **/
            portfolioAssetCount: AugmentedQuery<ApiType, (arg: PortfolioId | {
                did?: any;
                kind?: any;
            } | string | Uint8Array) => Observable<u64>, [
                PortfolioId
            ]>;
            /**
             * The custodian of a particular portfolio. None implies that the identity owner is the custodian.
             **/
            portfolioCustodian: AugmentedQuery<ApiType, (arg: PortfolioId | {
                did?: any;
                kind?: any;
            } | string | Uint8Array) => Observable<Option<IdentityId>>, [
                PortfolioId
            ]>;
            /**
             * Amount of assets locked in a portfolio.
             * These assets show up in portfolio balance but can not be transferred away.
             **/
            portfolioLockedAssets: AugmentedQuery<ApiType, (arg1: PortfolioId | {
                did?: any;
                kind?: any;
            } | string | Uint8Array, arg2: Ticker | string | Uint8Array) => Observable<Balance>, [
                PortfolioId,
                Ticker
            ]>;
            /**
             * The set of existing portfolios with their names. If a certain pair of a DID and
             * portfolio number maps to `None` then such a portfolio doesn't exist. Conversely, if a
             * pair maps to `Some(name)` then such a portfolio exists and is called `name`.
             **/
            portfolios: AugmentedQuery<ApiType, (arg1: IdentityId | string | Uint8Array, arg2: PortfolioNumber | AnyNumber | Uint8Array) => Observable<PortfolioName>, [
                IdentityId,
                PortfolioNumber
            ]>;
            /**
             * Tracks all the portfolios in custody of a particular identity. Only used by the UIs.
             * When `true` is stored as the value for a given `(did, pid)`, it means that `pid` is in custody of `did`.
             * `false` values are never explicitly stored in the map, and are instead inferred by the absence of a key.
             **/
            portfoliosInCustody: AugmentedQuery<ApiType, (arg1: IdentityId | string | Uint8Array, arg2: PortfolioId | {
                did?: any;
                kind?: any;
            } | string | Uint8Array) => Observable<bool>, [
                IdentityId,
                PortfolioId
            ]>;
            /**
             * Storage version.
             **/
            storageVersion: AugmentedQuery<ApiType, () => Observable<Version>, []>;
        };
        protocolFee: {
            /**
             * The mapping of operation names to the base fees of those operations.
             **/
            baseFees: AugmentedQuery<ApiType, (arg: ProtocolOp | 'AssetRegisterTicker' | 'AssetIssue' | 'AssetAddDocuments' | 'AssetCreateAsset' | 'CheckpointCreateSchedule' | 'ComplianceManagerAddComplianceRequirement' | 'IdentityCddRegisterDid' | 'IdentityAddClaim' | 'IdentityAddSecondaryKeysWithAuthorization' | 'PipsPropose' | 'ContractsPutCode' | 'CorporateBallotAttachBallot' | 'CapitalDistributionDistribute' | number | Uint8Array) => Observable<Balance>, [
                ProtocolOp
            ]>;
            /**
             * The fee coefficient as a positive rational (numerator, denominator).
             **/
            coefficient: AugmentedQuery<ApiType, () => Observable<PosRatio>, []>;
        };
        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<Hash>>, []>;
        };
        relayer: {
            /**
             * The subsidy for a `user_key` if they are being subsidised,
             * as a map `user_key` => `Subsidy`.
             *
             * A key can only have one subsidy at a time.  To change subsidisers
             * a key needs to call `remove_paying_key` to remove the current subsidy,
             * before they can accept a new subsidiser.
             **/
            subsidies: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Option<Subsidy>>, [
                AccountId
            ]>;
        };
        rewards: {
            /**
             * Map of (Itn Address `AccountId`) -> (Reward `ItnRewardStatus`).
             **/
            itnRewards: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Option<ItnRewardStatus>>, [
                AccountId
            ]>;
        };
        scheduler: {
            /**
             * Items to be executed, indexed by the block number that they should be executed on.
             **/
            agenda: AugmentedQuery<ApiType, (arg: BlockNumber | AnyNumber | Uint8Array) => Observable<Vec<Option<Scheduled>>>, [
                BlockNumber
            ]>;
            /**
             * Lookup from identity to the block number and index of the task.
             **/
            lookup: AugmentedQuery<ApiType, (arg: Bytes | string | Uint8Array) => Observable<Option<TaskAddress>>, [
                Bytes
            ]>;
            /**
             * Storage version of the pallet.
             *
             * New networks start with last version.
             **/
            storageVersion: AugmentedQuery<ApiType, () => Observable<Releases>, []>;
        };
        session: {
            /**
             * Current index of the session.
             **/
            currentIndex: AugmentedQuery<ApiType, () => Observable<SessionIndex>, []>;
            /**
             * Indices of disabled validators.
             *
             * The set is 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<[KeyTypeId, Bytes]> | [KeyTypeId | AnyNumber | Uint8Array, Bytes | string | Uint8Array]) => Observable<Option<ValidatorId>>, [
                ITuple<[KeyTypeId, Bytes]>
            ]>;
            /**
             * The next session keys for a validator.
             **/
            nextKeys: AugmentedQuery<ApiType, (arg: ValidatorId | string | Uint8Array) => Observable<Option<Keys>>, [
                ValidatorId
            ]>;
            /**
             * 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<[ValidatorId, Keys]>>>, []>;
            /**
             * The current set of validators.
             **/
            validators: AugmentedQuery<ApiType, () => Observable<Vec<ValidatorId>>, []>;
        };
        settlement: {
            /**
             * Tracks affirmations received for an instruction. (instruction_id, counter_party) -> AffirmationStatus
             **/
            affirmsReceived: AugmentedQuery<ApiType, (arg1: InstructionId | AnyNumber | Uint8Array, arg2: PortfolioId | {
                did?: any;
                kind?: any;
            } | string | Uint8Array) => Observable<AffirmationStatus>, [
                InstructionId,
                PortfolioId
            ]>;
            /**
             * Free-form text about a venue. venue_id -> `VenueDetails`
             * Only needed for the UI.
             **/
            details: AugmentedQuery<ApiType, (arg: VenueId | AnyNumber | Uint8Array) => Observable<VenueDetails>, [
                VenueId
            ]>;
            /**
             * Number of affirmations pending before instruction is executed. instruction_id -> affirm_pending
             **/
            instructionAffirmsPending: AugmentedQuery<ApiType, (arg: InstructionId | AnyNumber | Uint8Array) => Observable<u64>, [
                InstructionId
            ]>;
            /**
             * Number of instructions in the system (It's one more than the actual number)
             **/
            instructionCounter: AugmentedQuery<ApiType, () => Observable<InstructionId>, []>;
            /**
             * Details about an instruction. instruction_id -> instruction_details
             **/
            instructionDetails: AugmentedQuery<ApiType, (arg: InstructionId | AnyNumber | Uint8Array) => Observable<Instruction>, [
                InstructionId
            ]>;
            /**
             * Legs under an instruction. (instruction_id, leg_id) -> Leg
             **/
            instructionLegs: AugmentedQuery<ApiType, (arg1: InstructionId | AnyNumber | Uint8Array, arg2: LegId | AnyNumber | Uint8Array) => Observable<Leg>, [
                InstructionId,
                LegId
            ]>;
            /**
             * Status of a leg under an instruction. (instruction_id, leg_id) -> LegStatus
             **/
            instructionLegStatus: AugmentedQuery<ApiType, (arg1: InstructionId | AnyNumber | Uint8Array, arg2: LegId | AnyNumber | Uint8Array) => Observable<LegStatus>, [
                InstructionId,
                LegId
            ]>;
            /**
             * Tracks redemption of receipts. (signer, receipt_uid) -> receipt_used
             **/
            receiptsUsed: AugmentedQuery<ApiType, (arg1: AccountId | string | Uint8Array, arg2: u64 | AnyNumber | Uint8Array) => Observable<bool>, [
                AccountId,
                u64
            ]>;
            /**
             * Storage version.
             **/
            storageVersion: AugmentedQuery<ApiType, () => Observable<Version>, []>;
            /**
             * Helps a user track their pending instructions and affirmations (only needed for UI).
             * (counter_party, instruction_id) -> AffirmationStatus
             **/
            userAffirmations: AugmentedQuery<ApiType, (arg1: PortfolioId | {
                did?: any;
                kind?: any;
            } | string | Uint8Array, arg2: InstructionId | AnyNumber | Uint8Array) => Observable<AffirmationStatus>, [
                PortfolioId,
                InstructionId
            ]>;
            /**
             * Array of venues created by an identity. Only needed for the UI. IdentityId -> Vec<venue_id>
             **/
            userVenues: AugmentedQuery<ApiType, (arg: IdentityId | string | Uint8Array) => Observable<Vec<VenueId>>, [
                IdentityId
            ]>;
            /**
             * Venues that are allowed to create instructions involving a particular ticker. Only used if filtering is enabled.
             * (ticker, venue_id) -> allowed
             **/
            venueAllowList: AugmentedQuery<ApiType, (arg1: Ticker | string | Uint8Array, arg2: VenueId | AnyNumber | Uint8Array) => Observable<bool>, [
                Ticker,
                VenueId
            ]>;
            /**
             * Number of venues in the system (It's one more than the actual number)
             **/
            venueCounter: AugmentedQuery<ApiType, () => Observable<VenueId>, []>;
            /**
             * Tracks if a token has enabled filtering venues that can create instructions involving their token. Ticker -> filtering_enabled
             **/
            venueFiltering: AugmentedQuery<ApiType, (arg: Ticker | string | Uint8Array) => Observable<bool>, [
                Ticker
            ]>;
            /**
             * Info about a venue. venue_id -> venue
             **/
            venueInfo: AugmentedQuery<ApiType, (arg: VenueId | AnyNumber | Uint8Array) => Observable<Option<Venue>>, [
                VenueId
            ]>;
            /**
             * Instructions under a venue.
             * Only needed for the UI.
             *
             * venue_id -> instruction_id -> ()
             **/
            venueInstructions: AugmentedQuery<ApiType, (arg1: VenueId | AnyNumber | Uint8Array, arg2: InstructionId | AnyNumber | Uint8Array) => Observable<ITuple<[]>>, [
                VenueId,
                InstructionId
            ]>;
            /**
             * Signers allowed by the venue. (venue_id, signer) -> bool
             **/
            venueSigners: AugmentedQuery<ApiType, (arg1: VenueId | AnyNumber | Uint8Array, arg2: AccountId | string | Uint8Array) => Observable<bool>, [
                VenueId,
                AccountId
            ]>;
        };
        staking: {
            /**
             * The active era information, it holds index and start.
             *
             * The active era is the era being currently rewarded. Validator set of this era must be
             * equal to [`SessionInterface::validators`].
             **/
            activeEra: AugmentedQuery<ApiType, () => Observable<Option<ActiveEraInfo>>, []>;
            /**
             * Map from all locked "stash" accounts to the controller account.
             **/
            bonded: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Option<AccountId>>, [
                AccountId
            ]>;
            /**
             * A mapping from still-bonded eras to the first session index of that era.
             *
             * Must contains information for eras for the range:
             * `[active_era - bounding_duration; active_era]`
             **/
            bondedEras: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[EraIndex, SessionIndex]>>>, [
            ]>;
            /**
             * The amount of currency given to reporters of a slash event which was
             * canceled by extraordinary circumstances (e.g. governance).
             **/
            canceledSlashPayout: AugmentedQuery<ApiType, () => Observable<BalanceOf>, []>;
            /**
             * The current era index.
             *
             * This is the latest planned era, depending on how the Session pallet queues the validator
             * set, it might be active or not.
             **/
            currentEra: AugmentedQuery<ApiType, () => Observable<Option<EraIndex>>, []>;
            /**
             * The earliest era for which we have a pending, unapplied slash.
             **/
            earliestUnappliedSlash: AugmentedQuery<ApiType, () => Observable<Option<EraIndex>>, []>;
            /**
             * Flag to control the execution of the offchain election. When `Open(_)`, we accept
             * solutions to be submitted.
             **/
            eraElectionStatus: AugmentedQuery<ApiType, () => Observable<ElectionStatus>, []>;
            /**
             * Rewards for the last `HISTORY_DEPTH` eras.
             * If reward hasn't been set or has been removed then 0 reward is returned.
             **/
            erasRewardPoints: AugmentedQuery<ApiType, (arg: EraIndex | AnyNumber | Uint8Array) => Observable<EraRewardPoints>, [
                EraIndex
            ]>;
            /**
             * Exposure of validator at era.
             *
             * This is keyed first by the era index to allow bulk deletion and then the stash account.
             *
             * Is it removed after `HISTORY_DEPTH` eras.
             * If stakers hasn't been set or has been removed then empty exposure is returned.
             **/
            erasStakers: AugmentedQuery<ApiType, (arg1: EraIndex | AnyNumber | Uint8Array, arg2: AccountId | string | Uint8Array) => Observable<Exposure>, [
                EraIndex,
                AccountId
            ]>;
            /**
             * Clipped Exposure of validator at era.
             *
             * This is similar to [`ErasStakers`] but number of nominators exposed is reduced to the
             * `T::MaxNominatorRewardedPerValidator` biggest stakers.
             * (Note: the field `total` and `own` of the exposure remains unchanged).
             * This is used to limit the i/o cost for the nominator payout.
             *
             * This is keyed fist by the era index to allow bulk deletion and then the stash account.
             *
             * Is it removed after `HISTORY_DEPTH` eras.
             * If stakers hasn't been set or has been removed then empty exposure is returned.
             **/
            erasStakersClipped: AugmentedQuery<ApiType, (arg1: EraIndex | AnyNumber | Uint8Array, arg2: AccountId | string | Uint8Array) => Observable<Exposure>, [
                EraIndex,
                AccountId
            ]>;
            /**
             * The session index at which the era start for the last `HISTORY_DEPTH` eras.
             *
             * Note: This tracks the starting session (i.e. session index when era start being active)
             * for the eras in `[CurrentEra - HISTORY_DEPTH, CurrentEra]`.
             **/
            erasStartSessionIndex: AugmentedQuery<ApiType, (arg: EraIndex | AnyNumber | Uint8Array) => Observable<Option<SessionIndex>>, [
                EraIndex
            ]>;
            /**
             * The total amount staked for the last `HISTORY_DEPTH` eras.
             * If total hasn't been set or has been removed then 0 stake is returned.
             **/
            erasTotalStake: AugmentedQuery<ApiType, (arg: EraIndex | AnyNumber | Uint8Array) => Observable<BalanceOf>, [
                EraIndex
            ]>;
            /**
             * Similar to `ErasStakers`, this holds the preferences of validators.
             *
             * This is keyed first by the era index to allow bulk deletion and then the stash account.
             *
             * Is it removed after `HISTORY_DEPTH` eras.
             **/
            erasValidatorPrefs: AugmentedQuery<ApiType, (arg1: EraIndex | AnyNumber | Uint8Array, arg2: AccountId | string | Uint8Array) => Observable<ValidatorPrefs>, [
                EraIndex,
                AccountId
            ]>;
            /**
             * The total validator era payout for the last `HISTORY_DEPTH` eras.
             *
             * Eras that haven't finished yet or has been removed doesn't have reward.
             **/
            erasValidatorReward: AugmentedQuery<ApiType, (arg: EraIndex | AnyNumber | Uint8Array) => Observable<Option<BalanceOf>>, [
                EraIndex
            ]>;
            /**
             * Mode of era forcing.
             **/
            forceEra: AugmentedQuery<ApiType, () => Observable<Forcing>, []>;
            /**
             * Number of eras to keep in history.
             *
             * Information is kept for eras in `[current_era - history_depth; current_era]`.
             *
             * Must be more than the number of eras delayed by session otherwise. I.e. active era must
             * always be in history. I.e. `active_era > current_era - history_depth` must be
             * guaranteed.
             **/
            historyDepth: AugmentedQuery<ApiType, () => Observable<u32>, []>;
            /**
             * Any validators that may never be slashed or forcibly kicked. It's a Vec since they're
             * easy to initialize and the performance hit is minimal (we expect no more than four
             * invulnerables) and restricted to testnets.
             **/
            invulnerables: AugmentedQuery<ApiType, () => Observable<Vec<AccountId>>, []>;
            /**
             * True if the current **planned** session is final. Note that this does not take era
             * forcing into account.
             **/
            isCurrentSessionFinal: AugmentedQuery<ApiType, () => Observable<bool>, []>;
            /**
             * Map from all (unlocked) "controller" accounts to the info regarding the staking.
             **/
            ledger: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Option<StakingLedger>>, [
                AccountId
            ]>;
            /**
             * The minimum amount with which a validator can bond.
             **/
            minimumBondThreshold: AugmentedQuery<ApiType, () => Observable<BalanceOf>, []>;
            /**
             * Minimum number of staking participants before emergency conditions are imposed.
             **/
            minimumValidatorCount: AugmentedQuery<ApiType, () => Observable<u32>, []>;
            /**
             * The map from nominator stash key to the set of stash keys of all validators to nominate.
             **/
            nominators: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Option<Nominations>>, [
                AccountId
            ]>;
            /**
             * All slashing events on nominators, mapped by era to the highest slash value of the era.
             **/
            nominatorSlashInEra: AugmentedQuery<ApiType, (arg1: EraIndex | AnyNumber | Uint8Array, arg2: AccountId | string | Uint8Array) => Observable<Option<BalanceOf>>, [
                EraIndex,
                AccountId
            ]>;
            /**
             * Where the reward payment should be made. Keyed by stash.
             **/
            payee: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<RewardDestination>, [
                AccountId
            ]>;
            /**
             * Entities that are allowed to run operator/validator nodes.
             **/
            permissionedIdentity: AugmentedQuery<ApiType, (arg: IdentityId | string | Uint8Array) => Observable<Option<PermissionedIdentityPrefs>>, [
                IdentityId
            ]>;
            /**
             * The next validator set. At the end of an era, if this is available (potentially from the
             * result of an offchain worker), it is immediately used. Otherwise, the on-chain election
             * is executed.
             **/
            queuedElected: AugmentedQuery<ApiType, () => Observable<Option<ElectionResult>>, []>;
            /**
             * The score of the current [`QueuedElected`].
             **/
            queuedScore: AugmentedQuery<ApiType, () => Observable<Option<ElectionScore>>, []>;
            slashingAllowedFor: AugmentedQuery<ApiType, () => Observable<SlashingSwitch>, []>;
            /**
             * Slashing spans for stash accounts.
             **/
            slashingSpans: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Option<SlashingSpans>>, [
                AccountId
            ]>;
            /**
             * The percentage of the slash that is distributed to reporters.
             *
             * The rest of the slashed value is handled by the `Slash`.
             **/
            slashRewardFraction: AugmentedQuery<ApiType, () => Observable<Perbill>, []>;
            /**
             * Snapshot of nominators at the beginning of the current election window. This should only
             * have a value when [`EraElectionStatus`] == `ElectionStatus::Open(_)`.
             **/
            snapshotNominators: AugmentedQuery<ApiType, () => Observable<Option<Vec<AccountId>>>, []>;
            /**
             * Snapshot of validators at the beginning of the current election window. This should only
             * have a value when [`EraElectionStatus`] == `ElectionStatus::Open(_)`.
             **/
            snapshotValidators: AugmentedQuery<ApiType, () => Observable<Option<Vec<AccountId>>>, []>;
            /**
             * Records information about the maximum slash of a stash within a slashing span,
             * as well as how much reward has been paid out.
             **/
            spanSlash: AugmentedQuery<ApiType, (arg: ITuple<[AccountId, SpanIndex]> | [AccountId | string | Uint8Array, SpanIndex | AnyNumber | Uint8Array]) => Observable<SpanRecord>, [
                ITuple<[AccountId, SpanIndex]>
            ]>;
            /**
             * True if network has been upgraded to this version.
             * Storage version of the pallet.
             *
             * This is set to v6.0.1 for new networks.
             **/
            storageVersion: AugmentedQuery<ApiType, () => Observable<Releases>, []>;
            /**
             * All unapplied slashes that are queued for later.
             **/
            unappliedSlashes: AugmentedQuery<ApiType, (arg: EraIndex | AnyNumber | Uint8Array) => Observable<Vec<UnappliedSlash>>, [
                EraIndex
            ]>;
            /**
             * Every validator has commission that should be in the range [0, Cap].
             **/
            validatorCommissionCap: AugmentedQuery<ApiType, () => Observable<Perbill>, []>;
            /**
             * The ideal number of staking participants.
             **/
            validatorCount: AugmentedQuery<ApiType, () => Observable<u32>, []>;
            /**
             * The map from (wannabe) validator stash key to the preferences of that validator.
             **/
            validators: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<ValidatorPrefs>, [
                AccountId
            ]>;
            /**
             * All slashing events on validators, mapped by era to the highest slash proportion
             * and slash value of the era.
             **/
            validatorSlashInEra: AugmentedQuery<ApiType, (arg1: EraIndex | AnyNumber | Uint8Array, arg2: AccountId | string | Uint8Array) => Observable<Option<ITuple<[Perbill, BalanceOf]>>>, [
                EraIndex,
                AccountId
            ]>;
        };
        statistics: {
            /**
             * Transfer managers currently enabled for an Asset.
             **/
            activeTransferManagers: AugmentedQuery<ApiType, (arg: Ticker | string | Uint8Array) => Observable<Vec<TransferManager>>, [
                Ticker
            ]>;
            /**
             * Entities exempt from transfer managers. Exemptions requirements are based on TMS.
             * TMs may require just the sender, just the receiver, both or either to be exempted.
             * CTM requires sender to be exempted while PTM requires receiver to be exempted.
             **/
            exemptEntities: AugmentedQuery<ApiType, (arg1: ITuple<[Ticker, TransferManager]> | [
                Ticker | string | Uint8Array,
                (TransferManager | {
                    CountTransferManager: any;
                } | {
                    PercentageTransferManager: any;
                } | string | Uint8Array)
            ], arg2: ScopeId | string | Uint8Array) => Observable<bool>, [
                ITuple<[Ticker, TransferManager]>,
                ScopeId
            ]>;
            /**
             * Number of current investors in an asset.
             **/
            investorCountPerAsset: AugmentedQuery<ApiType, (arg: Ticker | string | Uint8Array) => Observable<Counter>, [
                Ticker
            ]>;
        };
        sto: {
            /**
             * Total fundraisers created for a token.
             **/
            fundraiserCount: AugmentedQuery<ApiType, (arg: Ticker | string | Uint8Array) => Observable<FundraiserId>, [
                Ticker
            ]>;
            /**
             * Name for the Fundraiser. Only used offchain.
             * (ticker, fundraiser_id) -> Fundraiser name
             **/
            fundraiserNames: AugmentedQuery<ApiType, (arg1: Ticker | string | Uint8Array, arg2: FundraiserId | AnyNumber | Uint8Array) => Observable<FundraiserName>, [
                Ticker,
                FundraiserId
            ]>;
            /**
             * All fundraisers that are currently running.
             * (ticker, fundraiser_id) -> Fundraiser
             **/
            fundraisers: AugmentedQuery<ApiType, (arg1: Ticker | string | Uint8Array, arg2: FundraiserId | AnyNumber | Uint8Array) => Observable<Option<Fundraiser>>, [
                Ticker,
                FundraiserId
            ]>;
        };
        sudo: {
            /**
             * The `AccountId` of the sudo key.
             **/
            key: AugmentedQuery<ApiType, () => Observable<AccountId>, []>;
        };
        system: {
            /**
             * The full account information for a particular account ID.
             **/
            account: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<AccountInfo>, [
                AccountId
            ]>;
            /**
             * 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: BlockNumber | AnyNumber | Uint8Array) => Observable<Hash>, [
                BlockNumber
            ]>;
            /**
             * The current weight for the block.
             **/
            blockWeight: AugmentedQuery<ApiType, () => Observable<ConsumedWeight>, []>;
            /**
             * Digest of the current block, also part of the block header.
             **/
            digest: AugmentedQuery<ApiType, () => Observable<DigestOf>, []>;
            /**
             * The number of events in the `Events<T>` list.
             **/
            eventCount: AugmentedQuery<ApiType, () => Observable<EventIndex>, []>;
            /**
             * Events deposited for the current block.
             **/
            events: AugmentedQuery<ApiType, () => Observable<Vec<EventRecord>>, []>;
            /**
             * 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: Hash | string | Uint8Array) => Observable<Vec<ITuple<[BlockNumber, EventIndex]>>>, [
                Hash
            ]>;
            /**
             * The execution phase of the block.
             **/
            executionPhase: AugmentedQuery<ApiType, () => Observable<Option<Phase>>, []>;
            /**
             * 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<LastRuntimeUpgradeInfo>>, [
            ]>;
            /**
             * The current block number being processed. Set by `execute_block`.
             **/
            number: AugmentedQuery<ApiType, () => Observable<BlockNumber>, []>;
            /**
             * Hash of the previous block.
             **/
            parentHash: AugmentedQuery<ApiType, () => Observable<Hash>, []>;
            /**
             * True if we have upgraded so that AccountInfo contains two types of `RefCount`. False
             * (default) if not.
             **/
            upgradedToDualRefCount: AugmentedQuery<ApiType, () => Observable<bool>, []>;
            /**
             * True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.
             **/
            upgradedToU32RefCount: AugmentedQuery<ApiType, () => Observable<bool>, []>;
        };
        technicalCommittee: {
            /**
             * Time after which a proposal will expire.
             **/
            expiresAfter: AugmentedQuery<ApiType, () => Observable<MaybeBlock>, []>;
            /**
             * The current members of the committee.
             **/
            members: AugmentedQuery<ApiType, () => Observable<Vec<IdentityId>>, []>;
            /**
             * Proposals so far.
             **/
            proposalCount: AugmentedQuery<ApiType, () => Observable<u32>, []>;
            /**
             * Actual proposal for a given hash.
             **/
            proposalOf: AugmentedQuery<ApiType, (arg: Hash | string | Uint8Array) => Observable<Option<Call>>, [
                Hash
            ]>;
            /**
             * The hashes of the active proposals.
             **/
            proposals: AugmentedQuery<ApiType, () => Observable<Vec<Hash>>, []>;
            /**
             * Release coordinator.
             **/
            releaseCoordinator: AugmentedQuery<ApiType, () => Observable<Option<IdentityId>>, []>;
            /**
             * Storage version.
             **/
            storageVersion: AugmentedQuery<ApiType, () => Observable<Version>, []>;
            /**
             * Vote threshold for an approval.
             **/
            voteThreshold: AugmentedQuery<ApiType, () => Observable<ITuple<[u32, u32]>>, []>;
            /**
             * PolymeshVotes on a given proposal, if it is ongoing.
             **/
            voting: AugmentedQuery<ApiType, (arg: Hash | string | Uint8Array) => Observable<Option<PolymeshVotes>>, [
                Hash
            ]>;
        };
        technicalCommitteeMembership: {
            /**
             * The current "active" membership, stored as an ordered Vec.
             **/
            activeMembers: AugmentedQuery<ApiType, () => Observable<Vec<IdentityId>>, []>;
            /**
             * Limit of how many "active" members there can be.
             **/
            activeMembersLimit: AugmentedQuery<ApiType, () => Observable<u32>, []>;
            /**
             * The current "inactive" membership, stored as an ordered Vec.
             **/
            inactiveMembers: AugmentedQuery<ApiType, () => Observable<Vec<InactiveMember>>, []>;
        };
        testUtils: {};
        timestamp: {
            /**
             * Did the timestamp get updated in this block?
             **/
            didUpdate: AugmentedQuery<ApiType, () => Observable<bool>, []>;
            /**
             * Current time for the current block.
             **/
            now: AugmentedQuery<ApiType, () => Observable<Moment>, []>;
        };
        transactionPayment: {
            nextFeeMultiplier: AugmentedQuery<ApiType, () => Observable<Multiplier>, []>;
            storageVersion: AugmentedQuery<ApiType, () => Observable<Releases>, []>;
        };
        upgradeCommittee: {
            /**
             * Time after which a proposal will expire.
             **/
            expiresAfter: AugmentedQuery<ApiType, () => Observable<MaybeBlock>, []>;
            /**
             * The current members of the committee.
             **/
            members: AugmentedQuery<ApiType, () => Observable<Vec<IdentityId>>, []>;
            /**
             * Proposals so far.
             **/
            proposalCount: AugmentedQuery<ApiType, () => Observable<u32>, []>;
            /**
             * Actual proposal for a given hash.
             **/
            proposalOf: AugmentedQuery<ApiType, (arg: Hash | string | Uint8Array) => Observable<Option<Call>>, [
                Hash
            ]>;
            /**
             * The hashes of the active proposals.
             **/
            proposals: AugmentedQuery<ApiType, () => Observable<Vec<Hash>>, []>;
            /**
             * Release coordinator.
             **/
            releaseCoordinator: AugmentedQuery<ApiType, () => Observable<Option<IdentityId>>, []>;
            /**
             * Storage version.
             **/
            storageVersion: AugmentedQuery<ApiType, () => Observable<Version>, []>;
            /**
             * Vote threshold for an approval.
             **/
            voteThreshold: AugmentedQuery<ApiType, () => Observable<ITuple<[u32, u32]>>, []>;
            /**
             * PolymeshVotes on a given proposal, if it is ongoing.
             **/
            voting: AugmentedQuery<ApiType, (arg: Hash | string | Uint8Array) => Observable<Option<PolymeshVotes>>, [
                Hash
            ]>;
        };
        upgradeCommitteeMembership: {
            /**
             * The current "active" membership, stored as an ordered Vec.
             **/
            activeMembers: AugmentedQuery<ApiType, () => Observable<Vec<IdentityId>>, []>;
            /**
             * Limit of how many "active" members there can be.
             **/
            activeMembersLimit: AugmentedQuery<ApiType, () => Observable<u32>, []>;
            /**
             * The current "inactive" membership, stored as an ordered Vec.
             **/
            inactiveMembers: AugmentedQuery<ApiType, () => Observable<Vec<InactiveMember>>, []>;
        };
        utility: {
            nonces: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<AuthorizationNonce>, [
                AccountId
            ]>;
        };
    }
    interface QueryableStorage<ApiType extends ApiTypes> extends AugmentedQueries<ApiType> {
    }
}
//# sourceMappingURL=augment-api-query.d.ts.map