@dedot/api 0.0.1-alpha.32

package/chaintypes/substrate/consts.d.ts

@@ -0,0 +1,2132 @@
+import type { Bytes, FixedBytes, Perbill, Percent, Permill, Perquintill, RuntimeVersion } from '@dedot/codecs';
+import type { GenericChainConsts, RpcVersion } from '@dedot/types';
+import type { FrameSupportPalletId, FrameSupportTokensFungibleUnionOfNativeOrWithId, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, PalletContractsApiVersion, PalletContractsEnvironment, PalletContractsSchedule, PalletNftsBitFlagsPalletFeature, PalletReferendaTrackInfo, SpWeightsRuntimeDbWeight, SpWeightsWeightV2Weight } from './types.js';
+export interface ChainConsts<Rv extends RpcVersion> extends GenericChainConsts<Rv> {
+    /**
+     * Pallet `System`'s constants
+     **/
+    system: {
+        /**
+         * Block & extrinsics weights: base values and limits.
+         **/
+        blockWeights: FrameSystemLimitsBlockWeights;
+        /**
+         * The maximum length of a block (in bytes).
+         **/
+        blockLength: FrameSystemLimitsBlockLength;
+        /**
+         * Maximum number of block number to block hash mappings to keep (oldest pruned first).
+         **/
+        blockHashCount: number;
+        /**
+         * The weight of runtime database operations the runtime can invoke.
+         **/
+        dbWeight: SpWeightsRuntimeDbWeight;
+        /**
+         * Get the chain's in-code version.
+         **/
+        version: RuntimeVersion;
+        /**
+         * The designated SS58 prefix of this chain.
+         *
+         * This replaces the "ss58Format" property declared in the chain spec. Reason is
+         * that the runtime should know about the prefix in order to make use of it as
+         * an identifier of the chain.
+         **/
+        ss58Prefix: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Utility`'s constants
+     **/
+    utility: {
+        /**
+         * The limit on the number of batched calls.
+         **/
+        batchedCallsLimit: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Babe`'s constants
+     **/
+    babe: {
+        /**
+         * The amount of time, in slots, that each epoch should last.
+         * NOTE: Currently it is not possible to change the epoch duration after
+         * the chain has started. Attempting to do so will brick block production.
+         **/
+        epochDuration: bigint;
+        /**
+         * The expected average block time at which BABE should be creating
+         * blocks. Since BABE is probabilistic it is not trivial to figure out
+         * what the expected average block time should be based on the slot
+         * duration and the security parameter `c` (where `1 - c` represents
+         * the probability of a slot being empty).
+         **/
+        expectedBlockTime: bigint;
+        /**
+         * Max number of authorities allowed
+         **/
+        maxAuthorities: number;
+        /**
+         * The maximum number of nominators for each validator.
+         **/
+        maxNominators: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Timestamp`'s constants
+     **/
+    timestamp: {
+        /**
+         * The minimum period between blocks.
+         *
+         * Be aware that this is different to the *expected* period that the block production
+         * apparatus provides. Your chosen consensus system will generally work with this to
+         * determine a sensible block time. For example, in the Aura pallet it will be double this
+         * period on default settings.
+         **/
+        minimumPeriod: bigint;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Authorship`'s constants
+     **/
+    authorship: {
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Indices`'s constants
+     **/
+    indices: {
+        /**
+         * The deposit needed for reserving an index.
+         **/
+        deposit: bigint;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Balances`'s constants
+     **/
+    balances: {
+        /**
+         * The minimum amount required to keep an account open. MUST BE GREATER THAN ZERO!
+         *
+         * If you *really* need it to be zero, you can enable the feature `insecure_zero_ed` for
+         * this pallet. However, you do so at your own risk: this will open up a major DoS vector.
+         * In case you have multiple sources of provider references, you may also get unexpected
+         * behaviour if you set this to zero.
+         *
+         * Bottom line: Do yourself a favour and make it at least one!
+         **/
+        existentialDeposit: bigint;
+        /**
+         * The maximum number of locks that should exist on an account.
+         * Not strictly enforced, but used for weight estimation.
+         **/
+        maxLocks: number;
+        /**
+         * The maximum number of named reserves that can exist on an account.
+         **/
+        maxReserves: number;
+        /**
+         * The maximum number of individual freeze locks that can exist on an account at any time.
+         **/
+        maxFreezes: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `TransactionPayment`'s constants
+     **/
+    transactionPayment: {
+        /**
+         * A fee multiplier for `Operational` extrinsics to compute "virtual tip" to boost their
+         * `priority`
+         *
+         * This value is multiplied by the `final_fee` to obtain a "virtual tip" that is later
+         * added to a tip component in regular `priority` calculations.
+         * It means that a `Normal` transaction can front-run a similarly-sized `Operational`
+         * extrinsic (with no tip), by including a tip value greater than the virtual tip.
+         *
+         * ```rust,ignore
+         * // For `Normal`
+         * let priority = priority_calc(tip);
+         *
+         * // For `Operational`
+         * let virtual_tip = (inclusion_fee + tip) * OperationalFeeMultiplier;
+         * let priority = priority_calc(tip + virtual_tip);
+         * ```
+         *
+         * Note that since we use `final_fee` the multiplier applies also to the regular `tip`
+         * sent with the transaction. So, not only does the transaction get a priority bump based
+         * on the `inclusion_fee`, but we also amplify the impact of tips applied to `Operational`
+         * transactions.
+         **/
+        operationalFeeMultiplier: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `AssetTxPayment`'s constants
+     **/
+    assetTxPayment: {
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `AssetConversionTxPayment`'s constants
+     **/
+    assetConversionTxPayment: {
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `ElectionProviderMultiPhase`'s constants
+     **/
+    electionProviderMultiPhase: {
+        /**
+         * Duration of the unsigned phase.
+         **/
+        unsignedPhase: number;
+        /**
+         * Duration of the signed phase.
+         **/
+        signedPhase: number;
+        /**
+         * The minimum amount of improvement to the solution score that defines a solution as
+         * "better" in the Signed phase.
+         **/
+        betterSignedThreshold: Perbill;
+        /**
+         * The repeat threshold of the offchain worker.
+         *
+         * For example, if it is 5, that means that at least 5 blocks will elapse between attempts
+         * to submit the worker's solution.
+         **/
+        offchainRepeat: number;
+        /**
+         * The priority of the unsigned transaction submitted in the unsigned-phase
+         **/
+        minerTxPriority: bigint;
+        /**
+         * Maximum number of signed submissions that can be queued.
+         *
+         * It is best to avoid adjusting this during an election, as it impacts downstream data
+         * structures. In particular, `SignedSubmissionIndices<T>` is bounded on this value. If you
+         * update this value during an election, you _must_ ensure that
+         * `SignedSubmissionIndices.len()` is less than or equal to the new value. Otherwise,
+         * attempts to submit new solutions may cause a runtime panic.
+         **/
+        signedMaxSubmissions: number;
+        /**
+         * Maximum weight of a signed solution.
+         *
+         * If [`Config::MinerConfig`] is being implemented to submit signed solutions (outside of
+         * this pallet), then [`MinerConfig::solution_weight`] is used to compare against
+         * this value.
+         **/
+        signedMaxWeight: SpWeightsWeightV2Weight;
+        /**
+         * The maximum amount of unchecked solutions to refund the call fee for.
+         **/
+        signedMaxRefunds: number;
+        /**
+         * Base reward for a signed solution
+         **/
+        signedRewardBase: bigint;
+        /**
+         * Per-byte deposit for a signed solution.
+         **/
+        signedDepositByte: bigint;
+        /**
+         * Per-weight deposit for a signed solution.
+         **/
+        signedDepositWeight: bigint;
+        /**
+         * The maximum number of winners that can be elected by this `ElectionProvider`
+         * implementation.
+         *
+         * Note: This must always be greater or equal to `T::DataProvider::desired_targets()`.
+         **/
+        maxWinners: number;
+        minerMaxLength: number;
+        minerMaxWeight: SpWeightsWeightV2Weight;
+        minerMaxVotesPerVoter: number;
+        minerMaxWinners: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Staking`'s constants
+     **/
+    staking: {
+        /**
+         * Number of eras to keep in history.
+         *
+         * Following information is kept for eras in `[current_era -
+         * HistoryDepth, current_era]`: `ErasStakers`, `ErasStakersClipped`,
+         * `ErasValidatorPrefs`, `ErasValidatorReward`, `ErasRewardPoints`,
+         * `ErasTotalStake`, `ErasStartSessionIndex`, `ClaimedRewards`, `ErasStakersPaged`,
+         * `ErasStakersOverview`.
+         *
+         * Must be more than the number of eras delayed by session.
+         * I.e. active era must always be in history. I.e. `active_era >
+         * current_era - history_depth` must be guaranteed.
+         *
+         * If migrating an existing pallet from storage value to config value,
+         * this should be set to same value or greater as in storage.
+         *
+         * Note: `HistoryDepth` is used as the upper bound for the `BoundedVec`
+         * item `StakingLedger.legacy_claimed_rewards`. Setting this value lower than
+         * the existing value can lead to inconsistencies in the
+         * `StakingLedger` and will need to be handled properly in a migration.
+         * The test `reducing_history_depth_abrupt` shows this effect.
+         **/
+        historyDepth: number;
+        /**
+         * Number of sessions per era.
+         **/
+        sessionsPerEra: number;
+        /**
+         * Number of eras that staked funds must remain bonded for.
+         **/
+        bondingDuration: number;
+        /**
+         * Number of eras that slashes are deferred by, after computation.
+         *
+         * This should be less than the bonding duration. Set to 0 if slashes
+         * should be applied immediately, without opportunity for intervention.
+         **/
+        slashDeferDuration: number;
+        /**
+         * The maximum size of each `T::ExposurePage`.
+         *
+         * An `ExposurePage` is weakly bounded to a maximum of `MaxExposurePageSize`
+         * nominators.
+         *
+         * For older non-paged exposure, a reward payout was restricted to the top
+         * `MaxExposurePageSize` nominators. This is to limit the i/o cost for the
+         * nominator payout.
+         *
+         * Note: `MaxExposurePageSize` is used to bound `ClaimedRewards` and is unsafe to reduce
+         * without handling it in a migration.
+         **/
+        maxExposurePageSize: number;
+        /**
+         * The maximum number of `unlocking` chunks a [`StakingLedger`] can
+         * have. Effectively determines how many unique eras a staker may be
+         * unbonding in.
+         *
+         * Note: `MaxUnlockingChunks` is used as the upper bound for the
+         * `BoundedVec` item `StakingLedger.unlocking`. Setting this value
+         * lower than the existing value can lead to inconsistencies in the
+         * `StakingLedger` and will need to be handled properly in a runtime
+         * migration. The test `reducing_max_unlocking_chunks_abrupt` shows
+         * this effect.
+         **/
+        maxUnlockingChunks: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Session`'s constants
+     **/
+    session: {
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Democracy`'s constants
+     **/
+    democracy: {
+        /**
+         * The period between a proposal being approved and enacted.
+         *
+         * It should generally be a little more than the unstake period to ensure that
+         * voting stakers have an opportunity to remove themselves from the system in the case
+         * where they are on the losing side of a vote.
+         **/
+        enactmentPeriod: number;
+        /**
+         * How often (in blocks) new public referenda are launched.
+         **/
+        launchPeriod: number;
+        /**
+         * How often (in blocks) to check for new votes.
+         **/
+        votingPeriod: number;
+        /**
+         * The minimum period of vote locking.
+         *
+         * It should be no shorter than enactment period to ensure that in the case of an approval,
+         * those successful voters are locked into the consequences that their votes entail.
+         **/
+        voteLockingPeriod: number;
+        /**
+         * The minimum amount to be used as a deposit for a public referendum proposal.
+         **/
+        minimumDeposit: bigint;
+        /**
+         * Indicator for whether an emergency origin is even allowed to happen. Some chains may
+         * want to set this permanently to `false`, others may want to condition it on things such
+         * as an upgrade having happened recently.
+         **/
+        instantAllowed: boolean;
+        /**
+         * Minimum voting period allowed for a fast-track referendum.
+         **/
+        fastTrackVotingPeriod: number;
+        /**
+         * Period in blocks where an external proposal may not be re-submitted after being vetoed.
+         **/
+        cooloffPeriod: number;
+        /**
+         * The maximum number of votes for an account.
+         *
+         * Also used to compute weight, an overly big value can
+         * lead to extrinsic with very big weight: see `delegate` for instance.
+         **/
+        maxVotes: number;
+        /**
+         * The maximum number of public proposals that can exist at any time.
+         **/
+        maxProposals: number;
+        /**
+         * The maximum number of deposits a public proposal may have at any time.
+         **/
+        maxDeposits: number;
+        /**
+         * The maximum number of items which can be blacklisted.
+         **/
+        maxBlacklisted: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Council`'s constants
+     **/
+    council: {
+        /**
+         * The maximum weight of a dispatch call that can be proposed and executed.
+         **/
+        maxProposalWeight: SpWeightsWeightV2Weight;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `TechnicalCommittee`'s constants
+     **/
+    technicalCommittee: {
+        /**
+         * The maximum weight of a dispatch call that can be proposed and executed.
+         **/
+        maxProposalWeight: SpWeightsWeightV2Weight;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Elections`'s constants
+     **/
+    elections: {
+        /**
+         * Identifier for the elections-phragmen pallet's lock
+         **/
+        palletId: FixedBytes<8>;
+        /**
+         * How much should be locked up in order to submit one's candidacy.
+         **/
+        candidacyBond: bigint;
+        /**
+         * Base deposit associated with voting.
+         *
+         * This should be sensibly high to economically ensure the pallet cannot be attacked by
+         * creating a gigantic number of votes.
+         **/
+        votingBondBase: bigint;
+        /**
+         * The amount of bond that need to be locked for each vote (32 bytes).
+         **/
+        votingBondFactor: bigint;
+        /**
+         * Number of members to elect.
+         **/
+        desiredMembers: number;
+        /**
+         * Number of runners_up to keep.
+         **/
+        desiredRunnersUp: number;
+        /**
+         * How long each seat is kept. This defines the next block number at which an election
+         * round will happen. If set to zero, no elections are ever triggered and the module will
+         * be in passive mode.
+         **/
+        termDuration: number;
+        /**
+         * The maximum number of candidates in a phragmen election.
+         *
+         * Warning: This impacts the size of the election which is run onchain. Chose wisely, and
+         * consider how it will impact `T::WeightInfo::election_phragmen`.
+         *
+         * When this limit is reached no more candidates are accepted in the election.
+         **/
+        maxCandidates: number;
+        /**
+         * The maximum number of voters to allow in a phragmen election.
+         *
+         * Warning: This impacts the size of the election which is run onchain. Chose wisely, and
+         * consider how it will impact `T::WeightInfo::election_phragmen`.
+         *
+         * When the limit is reached the new voters are ignored.
+         **/
+        maxVoters: number;
+        /**
+         * Maximum numbers of votes per voter.
+         *
+         * Warning: This impacts the size of the election which is run onchain. Chose wisely, and
+         * consider how it will impact `T::WeightInfo::election_phragmen`.
+         **/
+        maxVotesPerVoter: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `TechnicalMembership`'s constants
+     **/
+    technicalMembership: {
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Grandpa`'s constants
+     **/
+    grandpa: {
+        /**
+         * Max Authorities in use
+         **/
+        maxAuthorities: number;
+        /**
+         * The maximum number of nominators for each validator.
+         **/
+        maxNominators: number;
+        /**
+         * The maximum number of entries to keep in the set id to session index mapping.
+         *
+         * Since the `SetIdSession` map is only used for validating equivocations this
+         * value should relate to the bonding duration of whatever staking system is
+         * being used (if any). If equivocation handling is not enabled then this value
+         * can be zero.
+         **/
+        maxSetIdSessionEntries: bigint;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Treasury`'s constants
+     **/
+    treasury: {
+        /**
+         * Fraction of a proposal's value that should be bonded in order to place the proposal.
+         * An accepted proposal gets these back. A rejected proposal does not.
+         **/
+        proposalBond: Permill;
+        /**
+         * Minimum amount of funds that should be placed in a deposit for making a proposal.
+         **/
+        proposalBondMinimum: bigint;
+        /**
+         * Maximum amount of funds that should be placed in a deposit for making a proposal.
+         **/
+        proposalBondMaximum: bigint | undefined;
+        /**
+         * Period between successive spends.
+         **/
+        spendPeriod: number;
+        /**
+         * Percentage of spare funds (if any) that are burnt per spend period.
+         **/
+        burn: Permill;
+        /**
+         * The treasury's pallet id, used for deriving its sovereign account ID.
+         **/
+        palletId: FrameSupportPalletId;
+        /**
+         * The maximum number of approvals that can wait in the spending queue.
+         *
+         * NOTE: This parameter is also used within the Bounties Pallet extension if enabled.
+         **/
+        maxApprovals: number;
+        /**
+         * The period during which an approved treasury spend has to be claimed.
+         **/
+        payoutPeriod: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `AssetRate`'s constants
+     **/
+    assetRate: {
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Contracts`'s constants
+     **/
+    contracts: {
+        /**
+         * Cost schedule and limits.
+         **/
+        schedule: PalletContractsSchedule;
+        /**
+         * The amount of balance a caller has to pay for each byte of storage.
+         *
+         * # Note
+         *
+         * Changing this value for an existing chain might need a storage migration.
+         **/
+        depositPerByte: bigint;
+        /**
+         * Fallback value to limit the storage deposit if it's not being set by the caller.
+         **/
+        defaultDepositLimit: bigint;
+        /**
+         * The amount of balance a caller has to pay for each storage item.
+         *
+         * # Note
+         *
+         * Changing this value for an existing chain might need a storage migration.
+         **/
+        depositPerItem: bigint;
+        /**
+         * The percentage of the storage deposit that should be held for using a code hash.
+         * Instantiating a contract, or calling [`chain_extension::Ext::lock_delegate_dependency`]
+         * protects the code from being removed. In order to prevent abuse these actions are
+         * protected with a percentage of the code deposit.
+         **/
+        codeHashLockupDepositPercent: Perbill;
+        /**
+         * The maximum length of a contract code in bytes.
+         *
+         * The value should be chosen carefully taking into the account the overall memory limit
+         * your runtime has, as well as the [maximum allowed callstack
+         * depth](#associatedtype.CallStack). Look into the `integrity_test()` for some insights.
+         **/
+        maxCodeLen: number;
+        /**
+         * The maximum allowable length in bytes for storage keys.
+         **/
+        maxStorageKeyLen: number;
+        /**
+         * The maximum number of delegate_dependencies that a contract can lock with
+         * [`chain_extension::Ext::lock_delegate_dependency`].
+         **/
+        maxDelegateDependencies: number;
+        /**
+         * Make contract callable functions marked as `#[unstable]` available.
+         *
+         * Contracts that use `#[unstable]` functions won't be able to be uploaded unless
+         * this is set to `true`. This is only meant for testnets and dev nodes in order to
+         * experiment with new features.
+         *
+         * # Warning
+         *
+         * Do **not** set to `true` on productions chains.
+         **/
+        unsafeUnstableInterface: boolean;
+        /**
+         * The maximum length of the debug buffer in bytes.
+         **/
+        maxDebugBufferLen: number;
+        /**
+         * Type that bundles together all the runtime configurable interface types.
+         *
+         * This is not a real config. We just mention the type here as constant so that
+         * its type appears in the metadata. Only valid value is `()`.
+         **/
+        environment: PalletContractsEnvironment;
+        /**
+         * The version of the HostFn APIs that are available in the runtime.
+         *
+         * Only valid value is `()`.
+         **/
+        apiVersion: PalletContractsApiVersion;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Sudo`'s constants
+     **/
+    sudo: {
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `ImOnline`'s constants
+     **/
+    imOnline: {
+        /**
+         * A configuration for base priority of unsigned transactions.
+         *
+         * This is exposed so that it can be tuned for particular runtime, when
+         * multiple pallets send unsigned transactions.
+         **/
+        unsignedPriority: bigint;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `AuthorityDiscovery`'s constants
+     **/
+    authorityDiscovery: {
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Offences`'s constants
+     **/
+    offences: {
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Historical`'s constants
+     **/
+    historical: {
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `RandomnessCollectiveFlip`'s constants
+     **/
+    randomnessCollectiveFlip: {
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Identity`'s constants
+     **/
+    identity: {
+        /**
+         * The amount held on deposit for a registered identity.
+         **/
+        basicDeposit: bigint;
+        /**
+         * The amount held on deposit per encoded byte for a registered identity.
+         **/
+        byteDeposit: bigint;
+        /**
+         * The amount held on deposit for a registered subaccount. This should account for the fact
+         * that one storage item's value will increase by the size of an account ID, and there will
+         * be another trie item whose value is the size of an account ID plus 32 bytes.
+         **/
+        subAccountDeposit: bigint;
+        /**
+         * The maximum number of sub-accounts allowed per identified account.
+         **/
+        maxSubAccounts: number;
+        /**
+         * Maxmimum number of registrars allowed in the system. Needed to bound the complexity
+         * of, e.g., updating judgements.
+         **/
+        maxRegistrars: number;
+        /**
+         * The number of blocks within which a username grant must be accepted.
+         **/
+        pendingUsernameExpiration: number;
+        /**
+         * The maximum length of a suffix.
+         **/
+        maxSuffixLength: number;
+        /**
+         * The maximum length of a username, including its suffix and any system-added delimiters.
+         **/
+        maxUsernameLength: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Society`'s constants
+     **/
+    society: {
+        /**
+         * The societies's pallet id
+         **/
+        palletId: FrameSupportPalletId;
+        /**
+         * The maximum number of strikes before a member gets funds slashed.
+         **/
+        graceStrikes: number;
+        /**
+         * The amount of incentive paid within each period. Doesn't include VoterTip.
+         **/
+        periodSpend: bigint;
+        /**
+         * The number of blocks on which new candidates should be voted on. Together with
+         * `ClaimPeriod`, this sums to the number of blocks between candidate intake periods.
+         **/
+        votingPeriod: number;
+        /**
+         * The number of blocks on which new candidates can claim their membership and be the
+         * named head.
+         **/
+        claimPeriod: number;
+        /**
+         * The maximum duration of the payout lock.
+         **/
+        maxLockDuration: number;
+        /**
+         * The number of blocks between membership challenges.
+         **/
+        challengePeriod: number;
+        /**
+         * The maximum number of payouts a member may have waiting unclaimed.
+         **/
+        maxPayouts: number;
+        /**
+         * The maximum number of bids at once.
+         **/
+        maxBids: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Recovery`'s constants
+     **/
+    recovery: {
+        /**
+         * The base amount of currency needed to reserve for creating a recovery configuration.
+         *
+         * This is held for an additional storage item whose value size is
+         * `2 + sizeof(BlockNumber, Balance)` bytes.
+         **/
+        configDepositBase: bigint;
+        /**
+         * The amount of currency needed per additional user when creating a recovery
+         * configuration.
+         *
+         * This is held for adding `sizeof(AccountId)` bytes more into a pre-existing storage
+         * value.
+         **/
+        friendDepositFactor: bigint;
+        /**
+         * The maximum amount of friends allowed in a recovery configuration.
+         *
+         * NOTE: The threshold programmed in this Pallet uses u16, so it does
+         * not really make sense to have a limit here greater than u16::MAX.
+         * But also, that is a lot more than you should probably set this value
+         * to anyway...
+         **/
+        maxFriends: number;
+        /**
+         * The base amount of currency needed to reserve for starting a recovery.
+         *
+         * This is primarily held for deterring malicious recovery attempts, and should
+         * have a value large enough that a bad actor would choose not to place this
+         * deposit. It also acts to fund additional storage item whose value size is
+         * `sizeof(BlockNumber, Balance + T * AccountId)` bytes. Where T is a configurable
+         * threshold.
+         **/
+        recoveryDeposit: bigint;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Vesting`'s constants
+     **/
+    vesting: {
+        /**
+         * The minimum amount transferred to call `vested_transfer`.
+         **/
+        minVestedTransfer: bigint;
+        maxVestingSchedules: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Scheduler`'s constants
+     **/
+    scheduler: {
+        /**
+         * The maximum weight that may be scheduled per block for any dispatchables.
+         **/
+        maximumWeight: SpWeightsWeightV2Weight;
+        /**
+         * The maximum number of scheduled calls in the queue for a single block.
+         *
+         * NOTE:
+         * + Dependent pallets' benchmarks might require a higher limit for the setting. Set a
+         * higher limit under `runtime-benchmarks` feature.
+         **/
+        maxScheduledPerBlock: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Glutton`'s constants
+     **/
+    glutton: {
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Preimage`'s constants
+     **/
+    preimage: {
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Proxy`'s constants
+     **/
+    proxy: {
+        /**
+         * The base amount of currency needed to reserve for creating a proxy.
+         *
+         * This is held for an additional storage item whose value size is
+         * `sizeof(Balance)` bytes and whose key size is `sizeof(AccountId)` bytes.
+         **/
+        proxyDepositBase: bigint;
+        /**
+         * The amount of currency needed per proxy added.
+         *
+         * This is held for adding 32 bytes plus an instance of `ProxyType` more into a
+         * pre-existing storage value. Thus, when configuring `ProxyDepositFactor` one should take
+         * into account `32 + proxy_type.encode().len()` bytes of data.
+         **/
+        proxyDepositFactor: bigint;
+        /**
+         * The maximum amount of proxies allowed for a single account.
+         **/
+        maxProxies: number;
+        /**
+         * The maximum amount of time-delayed announcements that are allowed to be pending.
+         **/
+        maxPending: number;
+        /**
+         * The base amount of currency needed to reserve for creating an announcement.
+         *
+         * This is held when a new storage item holding a `Balance` is created (typically 16
+         * bytes).
+         **/
+        announcementDepositBase: bigint;
+        /**
+         * The amount of currency needed per announcement made.
+         *
+         * This is held for adding an `AccountId`, `Hash` and `BlockNumber` (typically 68 bytes)
+         * into a pre-existing storage value.
+         **/
+        announcementDepositFactor: bigint;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Multisig`'s constants
+     **/
+    multisig: {
+        /**
+         * The base amount of currency needed to reserve for creating a multisig execution or to
+         * store a dispatch call for later.
+         *
+         * This is held for an additional storage item whose value size is
+         * `4 + sizeof((BlockNumber, Balance, AccountId))` bytes and whose key size is
+         * `32 + sizeof(AccountId)` bytes.
+         **/
+        depositBase: bigint;
+        /**
+         * The amount of currency needed per unit threshold when creating a multisig execution.
+         *
+         * This is held for adding 32 bytes more into a pre-existing storage value.
+         **/
+        depositFactor: bigint;
+        /**
+         * The maximum amount of signatories allowed in the multisig.
+         **/
+        maxSignatories: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Bounties`'s constants
+     **/
+    bounties: {
+        /**
+         * The amount held on deposit for placing a bounty proposal.
+         **/
+        bountyDepositBase: bigint;
+        /**
+         * The delay period for which a bounty beneficiary need to wait before claim the payout.
+         **/
+        bountyDepositPayoutDelay: number;
+        /**
+         * Bounty duration in blocks.
+         **/
+        bountyUpdatePeriod: number;
+        /**
+         * The curator deposit is calculated as a percentage of the curator fee.
+         *
+         * This deposit has optional upper and lower bounds with `CuratorDepositMax` and
+         * `CuratorDepositMin`.
+         **/
+        curatorDepositMultiplier: Permill;
+        /**
+         * Maximum amount of funds that should be placed in a deposit for making a proposal.
+         **/
+        curatorDepositMax: bigint | undefined;
+        /**
+         * Minimum amount of funds that should be placed in a deposit for making a proposal.
+         **/
+        curatorDepositMin: bigint | undefined;
+        /**
+         * Minimum value for a bounty.
+         **/
+        bountyValueMinimum: bigint;
+        /**
+         * The amount held on deposit per byte within the tip report reason or bounty description.
+         **/
+        dataDepositPerByte: bigint;
+        /**
+         * Maximum acceptable reason length.
+         *
+         * Benchmarks depend on this value, be sure to update weights file when changing this value
+         **/
+        maximumReasonLength: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Tips`'s constants
+     **/
+    tips: {
+        /**
+         * Maximum acceptable reason length.
+         *
+         * Benchmarks depend on this value, be sure to update weights file when changing this value
+         **/
+        maximumReasonLength: number;
+        /**
+         * The amount held on deposit per byte within the tip report reason or bounty description.
+         **/
+        dataDepositPerByte: bigint;
+        /**
+         * The period for which a tip remains open after is has achieved threshold tippers.
+         **/
+        tipCountdown: number;
+        /**
+         * The percent of the final tip which goes to the original reporter of the tip.
+         **/
+        tipFindersFee: Percent;
+        /**
+         * The non-zero amount held on deposit for placing a tip report.
+         **/
+        tipReportDepositBase: bigint;
+        /**
+         * The maximum amount for a single tip.
+         **/
+        maxTipAmount: bigint;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Assets`'s constants
+     **/
+    assets: {
+        /**
+         * Max number of items to destroy per `destroy_accounts` and `destroy_approvals` call.
+         *
+         * Must be configured to result in a weight that makes each call fit in a block.
+         **/
+        removeItemsLimit: number;
+        /**
+         * The basic amount of funds that must be reserved for an asset.
+         **/
+        assetDeposit: bigint;
+        /**
+         * The amount of funds that must be reserved for a non-provider asset account to be
+         * maintained.
+         **/
+        assetAccountDeposit: bigint;
+        /**
+         * The basic amount of funds that must be reserved when adding metadata to your asset.
+         **/
+        metadataDepositBase: bigint;
+        /**
+         * The additional funds that must be reserved for the number of bytes you store in your
+         * metadata.
+         **/
+        metadataDepositPerByte: bigint;
+        /**
+         * The amount of funds that must be reserved when creating a new approval.
+         **/
+        approvalDeposit: bigint;
+        /**
+         * The maximum length of a name or symbol stored on-chain.
+         **/
+        stringLimit: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `PoolAssets`'s constants
+     **/
+    poolAssets: {
+        /**
+         * Max number of items to destroy per `destroy_accounts` and `destroy_approvals` call.
+         *
+         * Must be configured to result in a weight that makes each call fit in a block.
+         **/
+        removeItemsLimit: number;
+        /**
+         * The basic amount of funds that must be reserved for an asset.
+         **/
+        assetDeposit: bigint;
+        /**
+         * The amount of funds that must be reserved for a non-provider asset account to be
+         * maintained.
+         **/
+        assetAccountDeposit: bigint;
+        /**
+         * The basic amount of funds that must be reserved when adding metadata to your asset.
+         **/
+        metadataDepositBase: bigint;
+        /**
+         * The additional funds that must be reserved for the number of bytes you store in your
+         * metadata.
+         **/
+        metadataDepositPerByte: bigint;
+        /**
+         * The amount of funds that must be reserved when creating a new approval.
+         **/
+        approvalDeposit: bigint;
+        /**
+         * The maximum length of a name or symbol stored on-chain.
+         **/
+        stringLimit: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Beefy`'s constants
+     **/
+    beefy: {
+        /**
+         * The maximum number of authorities that can be added.
+         **/
+        maxAuthorities: number;
+        /**
+         * The maximum number of nominators for each validator.
+         **/
+        maxNominators: number;
+        /**
+         * The maximum number of entries to keep in the set id to session index mapping.
+         *
+         * Since the `SetIdSession` map is only used for validating equivocations this
+         * value should relate to the bonding duration of whatever staking system is
+         * being used (if any). If equivocation handling is not enabled then this value
+         * can be zero.
+         **/
+        maxSetIdSessionEntries: bigint;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Mmr`'s constants
+     **/
+    mmr: {
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `MmrLeaf`'s constants
+     **/
+    mmrLeaf: {
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Lottery`'s constants
+     **/
+    lottery: {
+        /**
+         * The Lottery's pallet id
+         **/
+        palletId: FrameSupportPalletId;
+        /**
+         * The max number of calls available in a single lottery.
+         **/
+        maxCalls: number;
+        /**
+         * Number of time we should try to generate a random number that has no modulo bias.
+         * The larger this number, the more potential computation is used for picking the winner,
+         * but also the more likely that the chosen winner is done fairly.
+         **/
+        maxGenerateRandom: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Nis`'s constants
+     **/
+    nis: {
+        /**
+         * The treasury's pallet id, used for deriving its sovereign account ID.
+         **/
+        palletId: FrameSupportPalletId;
+        /**
+         * Number of duration queues in total. This sets the maximum duration supported, which is
+         * this value multiplied by `Period`.
+         **/
+        queueCount: number;
+        /**
+         * Maximum number of items that may be in each duration queue.
+         *
+         * Must be larger than zero.
+         **/
+        maxQueueLen: number;
+        /**
+         * Portion of the queue which is free from ordering and just a FIFO.
+         *
+         * Must be no greater than `MaxQueueLen`.
+         **/
+        fifoQueueLen: number;
+        /**
+         * The base period for the duration queues. This is the common multiple across all
+         * supported freezing durations that can be bid upon.
+         **/
+        basePeriod: number;
+        /**
+         * The minimum amount of funds that may be placed in a bid. Note that this
+         * does not actually limit the amount which may be represented in a receipt since bids may
+         * be split up by the system.
+         *
+         * It should be at least big enough to ensure that there is no possible storage spam attack
+         * or queue-filling attack.
+         **/
+        minBid: bigint;
+        /**
+         * The minimum amount of funds which may intentionally be left remaining under a single
+         * receipt.
+         **/
+        minReceipt: Perquintill;
+        /**
+         * The number of blocks between consecutive attempts to dequeue bids and create receipts.
+         *
+         * A larger value results in fewer storage hits each block, but a slower period to get to
+         * the target.
+         **/
+        intakePeriod: number;
+        /**
+         * The maximum amount of bids that can consolidated into receipts in a single intake. A
+         * larger value here means less of the block available for transactions should there be a
+         * glut of bids.
+         **/
+        maxIntakeWeight: SpWeightsWeightV2Weight;
+        /**
+         * The maximum proportion which may be thawed and the period over which it is reset.
+         **/
+        thawThrottle: [Perquintill, number];
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Uniques`'s constants
+     **/
+    uniques: {
+        /**
+         * The basic amount of funds that must be reserved for collection.
+         **/
+        collectionDeposit: bigint;
+        /**
+         * The basic amount of funds that must be reserved for an item.
+         **/
+        itemDeposit: bigint;
+        /**
+         * The basic amount of funds that must be reserved when adding metadata to your item.
+         **/
+        metadataDepositBase: bigint;
+        /**
+         * The basic amount of funds that must be reserved when adding an attribute to an item.
+         **/
+        attributeDepositBase: bigint;
+        /**
+         * The additional funds that must be reserved for the number of bytes store in metadata,
+         * either "normal" metadata or attribute metadata.
+         **/
+        depositPerByte: bigint;
+        /**
+         * The maximum length of data stored on-chain.
+         **/
+        stringLimit: number;
+        /**
+         * The maximum length of an attribute key.
+         **/
+        keyLimit: number;
+        /**
+         * The maximum length of an attribute value.
+         **/
+        valueLimit: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Nfts`'s constants
+     **/
+    nfts: {
+        /**
+         * The basic amount of funds that must be reserved for collection.
+         **/
+        collectionDeposit: bigint;
+        /**
+         * The basic amount of funds that must be reserved for an item.
+         **/
+        itemDeposit: bigint;
+        /**
+         * The basic amount of funds that must be reserved when adding metadata to your item.
+         **/
+        metadataDepositBase: bigint;
+        /**
+         * The basic amount of funds that must be reserved when adding an attribute to an item.
+         **/
+        attributeDepositBase: bigint;
+        /**
+         * The additional funds that must be reserved for the number of bytes store in metadata,
+         * either "normal" metadata or attribute metadata.
+         **/
+        depositPerByte: bigint;
+        /**
+         * The maximum length of data stored on-chain.
+         **/
+        stringLimit: number;
+        /**
+         * The maximum length of an attribute key.
+         **/
+        keyLimit: number;
+        /**
+         * The maximum length of an attribute value.
+         **/
+        valueLimit: number;
+        /**
+         * The maximum approvals an item could have.
+         **/
+        approvalsLimit: number;
+        /**
+         * The maximum attributes approvals an item could have.
+         **/
+        itemAttributesApprovalsLimit: number;
+        /**
+         * The max number of tips a user could send.
+         **/
+        maxTips: number;
+        /**
+         * The max duration in blocks for deadlines.
+         **/
+        maxDeadlineDuration: number;
+        /**
+         * The max number of attributes a user could set per call.
+         **/
+        maxAttributesPerCall: number;
+        /**
+         * Disables some of pallet's features.
+         **/
+        features: PalletNftsBitFlagsPalletFeature;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `NftFractionalization`'s constants
+     **/
+    nftFractionalization: {
+        /**
+         * The deposit paid by the user locking an NFT. The deposit is returned to the original NFT
+         * owner when the asset is unified and the NFT is unlocked.
+         **/
+        deposit: bigint;
+        /**
+         * The pallet's id, used for deriving its sovereign account ID.
+         **/
+        palletId: FrameSupportPalletId;
+        /**
+         * The newly created asset's symbol.
+         **/
+        newAssetSymbol: Bytes;
+        /**
+         * The newly created asset's name.
+         **/
+        newAssetName: Bytes;
+        /**
+         * The maximum length of a name or symbol stored on-chain.
+         **/
+        stringLimit: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Salary`'s constants
+     **/
+    salary: {
+        /**
+         * The number of blocks within a cycle which accounts have to register their intent to
+         * claim.
+         *
+         * The number of blocks between sequential payout cycles is the sum of this and
+         * `PayoutPeriod`.
+         **/
+        registrationPeriod: number;
+        /**
+         * The number of blocks within a cycle which accounts have to claim the payout.
+         *
+         * The number of blocks between sequential payout cycles is the sum of this and
+         * `RegistrationPeriod`.
+         **/
+        payoutPeriod: number;
+        /**
+         * The total budget per cycle.
+         *
+         * This may change over the course of a cycle without any problem.
+         **/
+        budget: bigint;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `CoreFellowship`'s constants
+     **/
+    coreFellowship: {
+        /**
+         * The maximum size in bytes submitted evidence is allowed to be.
+         **/
+        evidenceSize: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `TransactionStorage`'s constants
+     **/
+    transactionStorage: {
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `VoterList`'s constants
+     **/
+    voterList: {
+        /**
+         * The list of thresholds separating the various bags.
+         *
+         * Ids are separated into unsorted bags according to their score. This specifies the
+         * thresholds separating the bags. An id's bag is the largest bag for which the id's score
+         * is less than or equal to its upper threshold.
+         *
+         * When ids are iterated, higher bags are iterated completely before lower bags. This means
+         * that iteration is _semi-sorted_: ids of higher score tend to come before ids of lower
+         * score, but peer ids within a particular bag are sorted in insertion order.
+         *
+         * # Expressing the constant
+         *
+         * This constant must be sorted in strictly increasing order. Duplicate items are not
+         * permitted.
+         *
+         * There is an implied upper limit of `Score::MAX`; that value does not need to be
+         * specified within the bag. For any two threshold lists, if one ends with
+         * `Score::MAX`, the other one does not, and they are otherwise equal, the two
+         * lists will behave identically.
+         *
+         * # Calculation
+         *
+         * It is recommended to generate the set of thresholds in a geometric series, such that
+         * there exists some constant ratio such that `threshold[k + 1] == (threshold[k] *
+         * constant_ratio).max(threshold[k] + 1)` for all `k`.
+         *
+         * The helpers in the `/utils/frame/generate-bags` module can simplify this calculation.
+         *
+         * # Examples
+         *
+         * - If `BagThresholds::get().is_empty()`, then all ids are put into the same bag, and
+         * iteration is strictly in insertion order.
+         * - If `BagThresholds::get().len() == 64`, and the thresholds are determined according to
+         * the procedure given above, then the constant ratio is equal to 2.
+         * - If `BagThresholds::get().len() == 200`, and the thresholds are determined according to
+         * the procedure given above, then the constant ratio is approximately equal to 1.248.
+         * - If the threshold list begins `[1, 2, 3, ...]`, then an id with score 0 or 1 will fall
+         * into bag 0, an id with score 2 will fall into bag 1, etc.
+         *
+         * # Migration
+         *
+         * In the event that this list ever changes, a copy of the old bags list must be retained.
+         * With that `List::migrate` can be called, which will perform the appropriate migration.
+         **/
+        bagThresholds: Array<bigint>;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `StateTrieMigration`'s constants
+     **/
+    stateTrieMigration: {
+        /**
+         * Maximal number of bytes that a key can have.
+         *
+         * FRAME itself does not limit the key length.
+         * The concrete value must therefore depend on your storage usage.
+         * A [`frame_support::storage::StorageNMap`] for example can have an arbitrary number of
+         * keys which are then hashed and concatenated, resulting in arbitrarily long keys.
+         *
+         * Use the *state migration RPC* to retrieve the length of the longest key in your
+         * storage: <https://github.com/paritytech/substrate/issues/11642>
+         *
+         * The migration will halt with a `Halted` event if this value is too small.
+         * Since there is no real penalty from over-estimating, it is advised to use a large
+         * value. The default is 512 byte.
+         *
+         * Some key lengths for reference:
+         * - [`frame_support::storage::StorageValue`]: 32 byte
+         * - [`frame_support::storage::StorageMap`]: 64 byte
+         * - [`frame_support::storage::StorageDoubleMap`]: 96 byte
+         *
+         * For more info see
+         * <https://www.shawntabrizi.com/blog/substrate/querying-substrate-storage-via-rpc/>
+         **/
+        maxKeyLen: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `ChildBounties`'s constants
+     **/
+    childBounties: {
+        /**
+         * Maximum number of child bounties that can be added to a parent bounty.
+         **/
+        maxActiveChildBountyCount: number;
+        /**
+         * Minimum value for a child-bounty.
+         **/
+        childBountyValueMinimum: bigint;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Referenda`'s constants
+     **/
+    referenda: {
+        /**
+         * The minimum amount to be used as a deposit for a public referendum proposal.
+         **/
+        submissionDeposit: bigint;
+        /**
+         * Maximum size of the referendum queue for a single track.
+         **/
+        maxQueued: number;
+        /**
+         * The number of blocks after submission that a referendum must begin being decided by.
+         * Once this passes, then anyone may cancel the referendum.
+         **/
+        undecidingTimeout: number;
+        /**
+         * Quantization level for the referendum wakeup scheduler. A higher number will result in
+         * fewer storage reads/writes needed for smaller voters, but also result in delays to the
+         * automatic referendum status changes. Explicit servicing instructions are unaffected.
+         **/
+        alarmInterval: number;
+        /**
+         * Information concerning the different referendum tracks.
+         **/
+        tracks: Array<[number, PalletReferendaTrackInfo]>;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Remark`'s constants
+     **/
+    remark: {
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `RootTesting`'s constants
+     **/
+    rootTesting: {
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `ConvictionVoting`'s constants
+     **/
+    convictionVoting: {
+        /**
+         * The maximum number of concurrent votes an account may have.
+         *
+         * Also used to compute weight, an overly large value can lead to extrinsics with large
+         * weight estimation: see `delegate` for instance.
+         **/
+        maxVotes: number;
+        /**
+         * The minimum period of vote locking.
+         *
+         * It should be no shorter than enactment period to ensure that in the case of an approval,
+         * those successful voters are locked into the consequences that their votes entail.
+         **/
+        voteLockingPeriod: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Whitelist`'s constants
+     **/
+    whitelist: {
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `AllianceMotion`'s constants
+     **/
+    allianceMotion: {
+        /**
+         * The maximum weight of a dispatch call that can be proposed and executed.
+         **/
+        maxProposalWeight: SpWeightsWeightV2Weight;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Alliance`'s constants
+     **/
+    alliance: {
+        /**
+         * The maximum number of the unscrupulous items supported by the pallet.
+         **/
+        maxUnscrupulousItems: number;
+        /**
+         * The maximum length of a website URL.
+         **/
+        maxWebsiteUrlLength: number;
+        /**
+         * The deposit required for submitting candidacy.
+         **/
+        allyDeposit: bigint;
+        /**
+         * The maximum number of announcements.
+         **/
+        maxAnnouncementsCount: number;
+        /**
+         * The maximum number of members per member role.
+         **/
+        maxMembersCount: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `NominationPools`'s constants
+     **/
+    nominationPools: {
+        /**
+         * The nomination pool's pallet id.
+         **/
+        palletId: FrameSupportPalletId;
+        /**
+         * The maximum pool points-to-balance ratio that an `open` pool can have.
+         *
+         * This is important in the event slashing takes place and the pool's points-to-balance
+         * ratio becomes disproportional.
+         *
+         * Moreover, this relates to the `RewardCounter` type as well, as the arithmetic operations
+         * are a function of number of points, and by setting this value to e.g. 10, you ensure
+         * that the total number of points in the system are at most 10 times the total_issuance of
+         * the chain, in the absolute worse case.
+         *
+         * For a value of 10, the threshold would be a pool points-to-balance ratio of 10:1.
+         * Such a scenario would also be the equivalent of the pool being 90% slashed.
+         **/
+        maxPointsToBalance: number;
+        /**
+         * The maximum number of simultaneous unbonding chunks that can exist per member.
+         **/
+        maxUnbonding: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `RankedPolls`'s constants
+     **/
+    rankedPolls: {
+        /**
+         * The minimum amount to be used as a deposit for a public referendum proposal.
+         **/
+        submissionDeposit: bigint;
+        /**
+         * Maximum size of the referendum queue for a single track.
+         **/
+        maxQueued: number;
+        /**
+         * The number of blocks after submission that a referendum must begin being decided by.
+         * Once this passes, then anyone may cancel the referendum.
+         **/
+        undecidingTimeout: number;
+        /**
+         * Quantization level for the referendum wakeup scheduler. A higher number will result in
+         * fewer storage reads/writes needed for smaller voters, but also result in delays to the
+         * automatic referendum status changes. Explicit servicing instructions are unaffected.
+         **/
+        alarmInterval: number;
+        /**
+         * Information concerning the different referendum tracks.
+         **/
+        tracks: Array<[number, PalletReferendaTrackInfo]>;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `RankedCollective`'s constants
+     **/
+    rankedCollective: {
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `AssetConversion`'s constants
+     **/
+    assetConversion: {
+        /**
+         * A % the liquidity providers will take of every swap. Represents 10ths of a percent.
+         **/
+        lpFee: number;
+        /**
+         * A one-time fee to setup the pool.
+         **/
+        poolSetupFee: bigint;
+        /**
+         * Asset class from [`Config::Assets`] used to pay the [`Config::PoolSetupFee`].
+         **/
+        poolSetupFeeAsset: FrameSupportTokensFungibleUnionOfNativeOrWithId;
+        /**
+         * A fee to withdraw the liquidity.
+         **/
+        liquidityWithdrawalFee: Permill;
+        /**
+         * The minimum LP token amount that could be minted. Ameliorates rounding errors.
+         **/
+        mintMinLiquidity: bigint;
+        /**
+         * The max number of hops in a swap.
+         **/
+        maxSwapPathLength: number;
+        /**
+         * The pallet's id, used for deriving its sovereign account ID.
+         **/
+        palletId: FrameSupportPalletId;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `FastUnstake`'s constants
+     **/
+    fastUnstake: {
+        /**
+         * Deposit to take for unstaking, to make sure we're able to slash the it in order to cover
+         * the costs of resources on unsuccessful unstake.
+         **/
+        deposit: bigint;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `MessageQueue`'s constants
+     **/
+    messageQueue: {
+        /**
+         * The size of the page; this implies the maximum message size which can be sent.
+         *
+         * A good value depends on the expected message sizes, their weights, the weight that is
+         * available for processing them and the maximal needed message size. The maximal message
+         * size is slightly lower than this as defined by [`MaxMessageLenOf`].
+         **/
+        heapSize: number;
+        /**
+         * The maximum number of stale pages (i.e. of overweight messages) allowed before culling
+         * can happen. Once there are more stale pages than this, then historical pages may be
+         * dropped, even if they contain unprocessed overweight messages.
+         **/
+        maxStale: number;
+        /**
+         * The amount of weight (if any) which should be provided to the message queue for
+         * servicing enqueued items.
+         *
+         * This may be legitimately `None` in the case that you will call
+         * `ServiceQueues::service_queues` manually.
+         **/
+        serviceWeight: SpWeightsWeightV2Weight | undefined;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Pov`'s constants
+     **/
+    pov: {
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `TxPause`'s constants
+     **/
+    txPause: {
+        /**
+         * Maximum length for pallet name and call name SCALE encoded string names.
+         *
+         * TOO LONG NAMES WILL BE TREATED AS PAUSED.
+         **/
+        maxNameLen: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `SafeMode`'s constants
+     **/
+    safeMode: {
+        /**
+         * For how many blocks the safe-mode will be entered by [`Pallet::enter`].
+         **/
+        enterDuration: number;
+        /**
+         * For how many blocks the safe-mode can be extended by each [`Pallet::extend`] call.
+         *
+         * This does not impose a hard limit as the safe-mode can be extended multiple times.
+         **/
+        extendDuration: number;
+        /**
+         * The amount that will be reserved upon calling [`Pallet::enter`].
+         *
+         * `None` disallows permissionlessly enabling the safe-mode and is a sane default.
+         **/
+        enterDepositAmount: bigint | undefined;
+        /**
+         * The amount that will be reserved upon calling [`Pallet::extend`].
+         *
+         * `None` disallows permissionlessly extending the safe-mode and is a sane default.
+         **/
+        extendDepositAmount: bigint | undefined;
+        /**
+         * The minimal duration a deposit will remain reserved after safe-mode is entered or
+         * extended, unless [`Pallet::force_release_deposit`] is successfully called sooner.
+         *
+         * Every deposit is tied to a specific activation or extension, thus each deposit can be
+         * released independently after the delay for it has passed.
+         *
+         * `None` disallows permissionlessly releasing the safe-mode deposits and is a sane
+         * default.
+         **/
+        releaseDelay: number | undefined;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Statement`'s constants
+     **/
+    statement: {
+        /**
+         * Min balance for priority statements.
+         **/
+        statementCost: bigint;
+        /**
+         * Cost of data byte used for priority calculation.
+         **/
+        byteCost: bigint;
+        /**
+         * Minimum number of statements allowed per account.
+         **/
+        minAllowedStatements: number;
+        /**
+         * Maximum number of statements allowed per account.
+         **/
+        maxAllowedStatements: number;
+        /**
+         * Minimum data bytes allowed per account.
+         **/
+        minAllowedBytes: number;
+        /**
+         * Maximum data bytes allowed per account.
+         **/
+        maxAllowedBytes: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `MultiBlockMigrations`'s constants
+     **/
+    multiBlockMigrations: {
+        /**
+         * The maximal length of an encoded cursor.
+         *
+         * A good default needs to selected such that no migration will ever have a cursor with MEL
+         * above this limit. This is statically checked in `integrity_test`.
+         **/
+        cursorMaxLen: number;
+        /**
+         * The maximal length of an encoded identifier.
+         *
+         * A good default needs to selected such that no migration will ever have an identifier
+         * with MEL above this limit. This is statically checked in `integrity_test`.
+         **/
+        identifierMaxLen: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Broker`'s constants
+     **/
+    broker: {
+        /**
+         * Identifier from which the internal Pot is generated.
+         **/
+        palletId: FrameSupportPalletId;
+        /**
+         * Number of Relay-chain blocks per timeslice.
+         **/
+        timeslicePeriod: number;
+        /**
+         * Maximum number of legacy leases.
+         **/
+        maxLeasedCores: number;
+        /**
+         * Maximum number of system cores.
+         **/
+        maxReservedCores: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `TasksExample`'s constants
+     **/
+    tasksExample: {
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Mixnet`'s constants
+     **/
+    mixnet: {
+        /**
+         * The maximum number of authorities per session.
+         **/
+        maxAuthorities: number;
+        /**
+         * The maximum size of one of a mixnode's external addresses.
+         **/
+        maxExternalAddressSize: number;
+        /**
+         * The maximum number of external addresses for a mixnode.
+         **/
+        maxExternalAddressesPerMixnode: number;
+        /**
+         * Length of the first phase of each session (`CoverToCurrent`), in blocks.
+         **/
+        numCoverToCurrentBlocks: number;
+        /**
+         * Length of the second phase of each session (`RequestsToCurrent`), in blocks.
+         **/
+        numRequestsToCurrentBlocks: number;
+        /**
+         * Length of the third phase of each session (`CoverToPrev`), in blocks.
+         **/
+        numCoverToPrevBlocks: number;
+        /**
+         * The number of "slack" blocks at the start of each session, during which
+         * [`maybe_register`](Pallet::maybe_register) will not attempt to post registration
+         * transactions.
+         **/
+        numRegisterStartSlackBlocks: number;
+        /**
+         * The number of "slack" blocks at the end of each session.
+         * [`maybe_register`](Pallet::maybe_register) will try to register before this slack
+         * period, but may post registration transactions during the slack period as a last
+         * resort.
+         **/
+        numRegisterEndSlackBlocks: number;
+        /**
+         * Priority of unsigned transactions used to register mixnodes.
+         **/
+        registrationPriority: bigint;
+        /**
+         * Minimum number of mixnodes. If there are fewer than this many mixnodes registered for a
+         * session, the mixnet will not be active during the session.
+         **/
+        minMixnodes: number;
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `Parameters`'s constants
+     **/
+    parameters: {
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+    /**
+     * Pallet `SkipFeelessPayment`'s constants
+     **/
+    skipFeelessPayment: {
+        /**
+         * Generic pallet constant
+         **/
+        [name: string]: any;
+    };
+}