@pezkuwi/api-augment 16.5.5

package/build/substrate/consts.d.ts

@@ -0,0 +1,1876 @@
+import '@polkadot/api-base/types/consts';
+import type { ApiTypes, AugmentedConst } from '@pezkuwi/api-base/types';
+import type { Bytes, Option, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@pezkuwi/types-codec';
+import type { Codec, ITuple } from '@pezkuwi/types-codec/types';
+import type { AccountId32, Perbill, Percent, Permill, Perquintill } from '@pezkuwi/types/interfaces/runtime';
+import type { FrameSupportPalletId, FrameSupportTokensFungibleUnionOfNativeOrWithId, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, PalletContractsEnvironment, PalletContractsSchedule, PalletReferendaTrackDetails, SpVersionRuntimeVersion, SpWeightsRuntimeDbWeight, SpWeightsWeightV2Weight } from '@pezkuwi/types/lookup';
+export type __AugmentedConst<ApiType extends ApiTypes> = AugmentedConst<ApiType>;
+declare module '@polkadot/api-base/types/consts' {
+    interface AugmentedConsts<ApiType extends ApiTypes> {
+        alliance: {
+            /**
+             * The deposit required for submitting candidacy.
+             **/
+            allyDeposit: u128 & AugmentedConst<ApiType>;
+            /**
+             * The maximum number of announcements.
+             **/
+            maxAnnouncementsCount: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum number of members per member role.
+             **/
+            maxMembersCount: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum number of the unscrupulous items supported by the pallet.
+             **/
+            maxUnscrupulousItems: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum length of a website URL.
+             **/
+            maxWebsiteUrlLength: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        allianceMotion: {
+            /**
+             * The maximum weight of a dispatch call that can be proposed and executed.
+             **/
+            maxProposalWeight: SpWeightsWeightV2Weight & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        assetConversion: {
+            /**
+             * A fee to withdraw the liquidity.
+             **/
+            liquidityWithdrawalFee: Permill & AugmentedConst<ApiType>;
+            /**
+             * A % the liquidity providers will take of every swap. Represents 10ths of a percent.
+             **/
+            lpFee: u32 & AugmentedConst<ApiType>;
+            /**
+             * The max number of hops in a swap.
+             **/
+            maxSwapPathLength: u32 & AugmentedConst<ApiType>;
+            /**
+             * The minimum LP token amount that could be minted. Ameliorates rounding errors.
+             **/
+            mintMinLiquidity: u128 & AugmentedConst<ApiType>;
+            /**
+             * The pallet's id, used for deriving its sovereign account ID.
+             **/
+            palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
+            /**
+             * A one-time fee to setup the pool.
+             **/
+            poolSetupFee: u128 & AugmentedConst<ApiType>;
+            /**
+             * Asset class from [`Config::Assets`] used to pay the [`Config::PoolSetupFee`].
+             **/
+            poolSetupFeeAsset: FrameSupportTokensFungibleUnionOfNativeOrWithId & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        assetRewards: {
+            /**
+             * The pallet's unique identifier, used to derive the pool's account ID.
+             *
+             * The account ID is derived once during pool creation and stored in the storage.
+             **/
+            palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        assets: {
+            /**
+             * The amount of funds that must be reserved when creating a new approval.
+             **/
+            approvalDeposit: u128 & AugmentedConst<ApiType>;
+            /**
+             * The amount of funds that must be reserved for a non-provider asset account to be
+             * maintained.
+             **/
+            assetAccountDeposit: u128 & AugmentedConst<ApiType>;
+            /**
+             * The basic amount of funds that must be reserved for an asset.
+             **/
+            assetDeposit: u128 & AugmentedConst<ApiType>;
+            /**
+             * The basic amount of funds that must be reserved when adding metadata to your asset.
+             **/
+            metadataDepositBase: u128 & AugmentedConst<ApiType>;
+            /**
+             * The additional funds that must be reserved for the number of bytes you store in your
+             * metadata.
+             **/
+            metadataDepositPerByte: u128 & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum length of a name or symbol stored on-chain.
+             **/
+            stringLimit: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        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: u64 & AugmentedConst<ApiType>;
+            /**
+             * 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: u64 & AugmentedConst<ApiType>;
+            /**
+             * Max number of authorities allowed
+             **/
+            maxAuthorities: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum number of nominators for each validator.
+             **/
+            maxNominators: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        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: u128 & AugmentedConst<ApiType>;
+            /**
+             * The maximum number of individual freeze locks that can exist on an account at any time.
+             **/
+            maxFreezes: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum number of locks that should exist on an account.
+             * Not strictly enforced, but used for weight estimation.
+             *
+             * Use of locks is deprecated in favour of freezes. See `https://github.com/paritytech/substrate/pull/12951/`
+             **/
+            maxLocks: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum number of named reserves that can exist on an account.
+             *
+             * Use of reserves is deprecated in favour of holds. See `https://github.com/paritytech/substrate/pull/12951/`
+             **/
+            maxReserves: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        beefy: {
+            /**
+             * The maximum number of authorities that can be added.
+             **/
+            maxAuthorities: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum number of nominators for each validator.
+             **/
+            maxNominators: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: u64 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        bounties: {
+            /**
+             * The amount held on deposit for placing a bounty proposal.
+             **/
+            bountyDepositBase: u128 & AugmentedConst<ApiType>;
+            /**
+             * The delay period for which a bounty beneficiary need to wait before claim the payout.
+             **/
+            bountyDepositPayoutDelay: u32 & AugmentedConst<ApiType>;
+            /**
+             * The time limit for a curator to act before a bounty expires.
+             *
+             * The period that starts when a curator is approved, during which they must execute or
+             * update the bounty via `extend_bounty_expiry`. If missed, the bounty expires, and the
+             * curator may be slashed. If `BlockNumberFor::MAX`, bounties stay active indefinitely,
+             * removing the need for `extend_bounty_expiry`.
+             **/
+            bountyUpdatePeriod: u32 & AugmentedConst<ApiType>;
+            /**
+             * Minimum value for a bounty.
+             **/
+            bountyValueMinimum: u128 & AugmentedConst<ApiType>;
+            /**
+             * Maximum amount of funds that should be placed in a deposit for making a proposal.
+             **/
+            curatorDepositMax: Option<u128> & AugmentedConst<ApiType>;
+            /**
+             * Minimum amount of funds that should be placed in a deposit for making a proposal.
+             **/
+            curatorDepositMin: Option<u128> & AugmentedConst<ApiType>;
+            /**
+             * 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 & AugmentedConst<ApiType>;
+            /**
+             * The amount held on deposit per byte within the tip report reason or bounty description.
+             **/
+            dataDepositPerByte: u128 & AugmentedConst<ApiType>;
+            /**
+             * Maximum acceptable reason length.
+             *
+             * Benchmarks depend on this value, be sure to update weights file when changing this value
+             **/
+            maximumReasonLength: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        broker: {
+            /**
+             * Given that we are performing all auto-renewals in a single block, it has to be limited.
+             **/
+            maxAutoRenewals: u32 & AugmentedConst<ApiType>;
+            /**
+             * Maximum number of legacy leases.
+             **/
+            maxLeasedCores: u32 & AugmentedConst<ApiType>;
+            /**
+             * Maximum number of system cores.
+             **/
+            maxReservedCores: u32 & AugmentedConst<ApiType>;
+            /**
+             * The smallest amount of credits a user can purchase.
+             *
+             * Needed to prevent spam attacks.
+             **/
+            minimumCreditPurchase: u128 & AugmentedConst<ApiType>;
+            /**
+             * Identifier from which the internal Pot is generated.
+             **/
+            palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
+            /**
+             * Number of Relay-chain blocks per timeslice.
+             **/
+            timeslicePeriod: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        childBounties: {
+            /**
+             * Minimum value for a child-bounty.
+             **/
+            childBountyValueMinimum: u128 & AugmentedConst<ApiType>;
+            /**
+             * Maximum number of child bounties that can be added to a parent bounty.
+             **/
+            maxActiveChildBountyCount: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        contracts: {
+            /**
+             * The version of the HostFn APIs that are available in the runtime.
+             *
+             * Only valid value is `()`.
+             **/
+            apiVersion: u16 & AugmentedConst<ApiType>;
+            /**
+             * 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 & AugmentedConst<ApiType>;
+            /**
+             * Fallback value to limit the storage deposit if it's not being set by the caller.
+             **/
+            defaultDepositLimit: u128 & AugmentedConst<ApiType>;
+            /**
+             * 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: u128 & AugmentedConst<ApiType>;
+            /**
+             * 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: u128 & AugmentedConst<ApiType>;
+            /**
+             * 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 & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum length of the debug buffer in bytes.
+             **/
+            maxDebugBufferLen: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum number of delegate_dependencies that a contract can lock with
+             * [`chain_extension::Ext::lock_delegate_dependency`].
+             **/
+            maxDelegateDependencies: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum allowable length in bytes for storage keys.
+             **/
+            maxStorageKeyLen: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum size of the transient storage in bytes.
+             * This includes keys, values, and previous entries used for storage rollback.
+             **/
+            maxTransientStorageSize: u32 & AugmentedConst<ApiType>;
+            /**
+             * Cost schedule and limits.
+             **/
+            schedule: PalletContractsSchedule & AugmentedConst<ApiType>;
+            /**
+             * 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: bool & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        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: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        coreFellowship: {
+            /**
+             * The maximum size in bytes submitted evidence is allowed to be.
+             **/
+            evidenceSize: u32 & AugmentedConst<ApiType>;
+            /**
+             * Represents the highest possible rank in this pallet.
+             *
+             * Increasing this value is supported, but decreasing it may lead to a broken state.
+             **/
+            maxRank: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        council: {
+            /**
+             * The maximum weight of a dispatch call that can be proposed and executed.
+             **/
+            maxProposalWeight: SpWeightsWeightV2Weight & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        delegatedStaking: {
+            /**
+             * Injected identifier for the pallet.
+             **/
+            palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
+            /**
+             * Fraction of the slash that is rewarded to the caller of pending slash to the agent.
+             **/
+            slashRewardFraction: Perbill & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        democracy: {
+            /**
+             * Period in blocks where an external proposal may not be re-submitted after being vetoed.
+             **/
+            cooloffPeriod: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * Minimum voting period allowed for a fast-track referendum.
+             **/
+            fastTrackVotingPeriod: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: bool & AugmentedConst<ApiType>;
+            /**
+             * How often (in blocks) new public referenda are launched.
+             **/
+            launchPeriod: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum number of items which can be blacklisted.
+             **/
+            maxBlacklisted: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum number of deposits a public proposal may have at any time.
+             **/
+            maxDeposits: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum number of public proposals that can exist at any time.
+             **/
+            maxProposals: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * The minimum amount to be used as a deposit for a public referendum proposal.
+             **/
+            minimumDeposit: u128 & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * How often (in blocks) to check for new votes.
+             **/
+            votingPeriod: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        electionProviderMultiPhase: {
+            /**
+             * The minimum amount of improvement to the solution score that defines a solution as
+             * "better" in the Signed phase.
+             **/
+            betterSignedThreshold: Perbill & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            minerMaxLength: u32 & AugmentedConst<ApiType>;
+            minerMaxVotesPerVoter: u32 & AugmentedConst<ApiType>;
+            minerMaxWeight: SpWeightsWeightV2Weight & AugmentedConst<ApiType>;
+            minerMaxWinners: u32 & AugmentedConst<ApiType>;
+            /**
+             * The priority of the unsigned transaction submitted in the unsigned-phase
+             **/
+            minerTxPriority: u64 & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * Per-byte deposit for a signed solution.
+             **/
+            signedDepositByte: u128 & AugmentedConst<ApiType>;
+            /**
+             * Per-weight deposit for a signed solution.
+             **/
+            signedDepositWeight: u128 & AugmentedConst<ApiType>;
+            /**
+             * The maximum amount of unchecked solutions to refund the call fee for.
+             **/
+            signedMaxRefunds: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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 & AugmentedConst<ApiType>;
+            /**
+             * Base reward for a signed solution
+             **/
+            signedRewardBase: u128 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        elections: {
+            /**
+             * How much should be locked up in order to submit one's candidacy.
+             **/
+            candidacyBond: u128 & AugmentedConst<ApiType>;
+            /**
+             * Number of members to elect.
+             **/
+            desiredMembers: u32 & AugmentedConst<ApiType>;
+            /**
+             * Number of runners_up to keep.
+             **/
+            desiredRunnersUp: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * Identifier for the elections-phragmen pallet's lock
+             **/
+            palletId: U8aFixed & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: u128 & AugmentedConst<ApiType>;
+            /**
+             * The amount of bond that need to be locked for each vote (32 bytes).
+             **/
+            votingBondFactor: u128 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        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: u128 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        grandpa: {
+            /**
+             * Max Authorities in use
+             **/
+            maxAuthorities: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum number of nominators for each validator.
+             **/
+            maxNominators: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: u64 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        identity: {
+            /**
+             * The amount held on deposit for a registered identity.
+             **/
+            basicDeposit: u128 & AugmentedConst<ApiType>;
+            /**
+             * The amount held on deposit per encoded byte for a registered identity.
+             **/
+            byteDeposit: u128 & AugmentedConst<ApiType>;
+            /**
+             * Maximum number of registrars allowed in the system. Needed to bound the complexity
+             * of, e.g., updating judgements.
+             **/
+            maxRegistrars: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum number of sub-accounts allowed per identified account.
+             **/
+            maxSubAccounts: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum length of a suffix.
+             **/
+            maxSuffixLength: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum length of a username, including its suffix and any system-added delimiters.
+             **/
+            maxUsernameLength: u32 & AugmentedConst<ApiType>;
+            /**
+             * The number of blocks within which a username grant must be accepted.
+             **/
+            pendingUsernameExpiration: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: u128 & AugmentedConst<ApiType>;
+            /**
+             * The amount held on deposit per registered username. This value should change only in
+             * runtime upgrades with proper migration of existing deposits.
+             **/
+            usernameDeposit: u128 & AugmentedConst<ApiType>;
+            /**
+             * The number of blocks that must pass to enable the permanent deletion of a username by
+             * its respective authority.
+             **/
+            usernameGracePeriod: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        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: u64 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        indices: {
+            /**
+             * The deposit needed for reserving an index.
+             **/
+            deposit: u128 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        lottery: {
+            /**
+             * The max number of calls available in a single lottery.
+             **/
+            maxCalls: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * The Lottery's pallet id
+             **/
+            palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        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: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum amount of weight (if any) to be used from remaining weight `on_idle` which
+             * should be provided to the message queue for servicing enqueued items `on_idle`.
+             * Useful for parachains to process messages at the same block they are received.
+             *
+             * If `None`, it will not call `ServiceQueues::service_queues` in `on_idle`.
+             **/
+            idleMaxServiceWeight: Option<SpWeightsWeightV2Weight> & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * The amount of weight (if any) which should be provided to the message queue for
+             * servicing enqueued items `on_initialize`.
+             *
+             * This may be legitimately `None` in the case that you will call
+             * `ServiceQueues::service_queues` manually or set [`Self::IdleMaxServiceWeight`] to have
+             * it run in `on_idle`.
+             **/
+            serviceWeight: Option<SpWeightsWeightV2Weight> & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        mixnet: {
+            /**
+             * The maximum number of authorities per session.
+             **/
+            maxAuthorities: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum number of external addresses for a mixnode.
+             **/
+            maxExternalAddressesPerMixnode: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum size of one of a mixnode's external addresses.
+             **/
+            maxExternalAddressSize: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * Length of the first phase of each session (`CoverToCurrent`), in blocks.
+             **/
+            numCoverToCurrentBlocks: u32 & AugmentedConst<ApiType>;
+            /**
+             * Length of the third phase of each session (`CoverToPrev`), in blocks.
+             **/
+            numCoverToPrevBlocks: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * Length of the second phase of each session (`RequestsToCurrent`), in blocks.
+             **/
+            numRequestsToCurrentBlocks: u32 & AugmentedConst<ApiType>;
+            /**
+             * Priority of unsigned transactions used to register mixnodes.
+             **/
+            registrationPriority: u64 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        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: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        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: u128 & AugmentedConst<ApiType>;
+            /**
+             * 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: u128 & AugmentedConst<ApiType>;
+            /**
+             * The maximum amount of signatories allowed in the multisig.
+             **/
+            maxSignatories: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        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: u128 & AugmentedConst<ApiType>;
+            /**
+             * The newly created asset's name.
+             **/
+            newAssetName: Bytes & AugmentedConst<ApiType>;
+            /**
+             * The newly created asset's symbol.
+             **/
+            newAssetSymbol: Bytes & AugmentedConst<ApiType>;
+            /**
+             * The pallet's id, used for deriving its sovereign account ID.
+             **/
+            palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
+            /**
+             * The maximum length of a name or symbol stored on-chain.
+             **/
+            stringLimit: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        nfts: {
+            /**
+             * The maximum approvals an item could have.
+             **/
+            approvalsLimit: u32 & AugmentedConst<ApiType>;
+            /**
+             * The basic amount of funds that must be reserved when adding an attribute to an item.
+             **/
+            attributeDepositBase: u128 & AugmentedConst<ApiType>;
+            /**
+             * The basic amount of funds that must be reserved for collection.
+             **/
+            collectionDeposit: u128 & AugmentedConst<ApiType>;
+            /**
+             * The additional funds that must be reserved for the number of bytes store in metadata,
+             * either "normal" metadata or attribute metadata.
+             **/
+            depositPerByte: u128 & AugmentedConst<ApiType>;
+            /**
+             * Disables some of pallet's features.
+             **/
+            features: u64 & AugmentedConst<ApiType>;
+            /**
+             * The maximum attributes approvals an item could have.
+             **/
+            itemAttributesApprovalsLimit: u32 & AugmentedConst<ApiType>;
+            /**
+             * The basic amount of funds that must be reserved for an item.
+             **/
+            itemDeposit: u128 & AugmentedConst<ApiType>;
+            /**
+             * The maximum length of an attribute key.
+             **/
+            keyLimit: u32 & AugmentedConst<ApiType>;
+            /**
+             * The max number of attributes a user could set per call.
+             **/
+            maxAttributesPerCall: u32 & AugmentedConst<ApiType>;
+            /**
+             * The max duration in blocks for deadlines.
+             **/
+            maxDeadlineDuration: u32 & AugmentedConst<ApiType>;
+            /**
+             * The max number of tips a user could send.
+             **/
+            maxTips: u32 & AugmentedConst<ApiType>;
+            /**
+             * The basic amount of funds that must be reserved when adding metadata to your item.
+             **/
+            metadataDepositBase: u128 & AugmentedConst<ApiType>;
+            /**
+             * The maximum length of data stored on-chain.
+             **/
+            stringLimit: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum length of an attribute value.
+             **/
+            valueLimit: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        nis: {
+            /**
+             * The base period for the duration queues. This is the common multiple across all
+             * supported freezing durations that can be bid upon.
+             **/
+            basePeriod: u32 & AugmentedConst<ApiType>;
+            /**
+             * Portion of the queue which is free from ordering and just a FIFO.
+             *
+             * Must be no greater than `MaxQueueLen`.
+             **/
+            fifoQueueLen: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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 & AugmentedConst<ApiType>;
+            /**
+             * Maximum number of items that may be in each duration queue.
+             *
+             * Must be larger than zero.
+             **/
+            maxQueueLen: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: u128 & AugmentedConst<ApiType>;
+            /**
+             * The minimum amount of funds which may intentionally be left remaining under a single
+             * receipt.
+             **/
+            minReceipt: Perquintill & AugmentedConst<ApiType>;
+            /**
+             * The treasury's pallet id, used for deriving its sovereign account ID.
+             **/
+            palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
+            /**
+             * Number of duration queues in total. This sets the maximum duration supported, which is
+             * this value multiplied by `Period`.
+             **/
+            queueCount: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum proportion which may be thawed and the period over which it is reset.
+             **/
+            thawThrottle: ITuple<[Perquintill, u32]> & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        nominationPools: {
+            /**
+             * 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: u8 & AugmentedConst<ApiType>;
+            /**
+             * The maximum number of simultaneous unbonding chunks that can exist per member.
+             **/
+            maxUnbonding: u32 & AugmentedConst<ApiType>;
+            /**
+             * The nomination pool's pallet id.
+             **/
+            palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        poolAssets: {
+            /**
+             * The amount of funds that must be reserved when creating a new approval.
+             **/
+            approvalDeposit: u128 & AugmentedConst<ApiType>;
+            /**
+             * The amount of funds that must be reserved for a non-provider asset account to be
+             * maintained.
+             **/
+            assetAccountDeposit: u128 & AugmentedConst<ApiType>;
+            /**
+             * The basic amount of funds that must be reserved for an asset.
+             **/
+            assetDeposit: u128 & AugmentedConst<ApiType>;
+            /**
+             * The basic amount of funds that must be reserved when adding metadata to your asset.
+             **/
+            metadataDepositBase: u128 & AugmentedConst<ApiType>;
+            /**
+             * The additional funds that must be reserved for the number of bytes you store in your
+             * metadata.
+             **/
+            metadataDepositPerByte: u128 & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum length of a name or symbol stored on-chain.
+             **/
+            stringLimit: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        proxy: {
+            /**
+             * 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: u128 & AugmentedConst<ApiType>;
+            /**
+             * 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: u128 & AugmentedConst<ApiType>;
+            /**
+             * The maximum amount of time-delayed announcements that are allowed to be pending.
+             **/
+            maxPending: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum amount of proxies allowed for a single account.
+             **/
+            maxProxies: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: u128 & AugmentedConst<ApiType>;
+            /**
+             * 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: u128 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        rankedPolls: {
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * Maximum size of the referendum queue for a single track.
+             **/
+            maxQueued: u32 & AugmentedConst<ApiType>;
+            /**
+             * The minimum amount to be used as a deposit for a public referendum proposal.
+             **/
+            submissionDeposit: u128 & AugmentedConst<ApiType>;
+            /**
+             * A list of tracks.
+             *
+             * Note: if the tracks are dynamic, the value in the static metadata might be inaccurate.
+             **/
+            tracks: Vec<ITuple<[u16, PalletReferendaTrackDetails]>> & AugmentedConst<ApiType>;
+            /**
+             * The number of blocks after submission that a referendum must begin being decided by.
+             * Once this passes, then anyone may cancel the referendum.
+             **/
+            undecidingTimeout: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        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: u128 & AugmentedConst<ApiType>;
+            /**
+             * 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: u128 & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: u128 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        referenda: {
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * Maximum size of the referendum queue for a single track.
+             **/
+            maxQueued: u32 & AugmentedConst<ApiType>;
+            /**
+             * The minimum amount to be used as a deposit for a public referendum proposal.
+             **/
+            submissionDeposit: u128 & AugmentedConst<ApiType>;
+            /**
+             * A list of tracks.
+             *
+             * Note: if the tracks are dynamic, the value in the static metadata might be inaccurate.
+             **/
+            tracks: Vec<ITuple<[u16, PalletReferendaTrackDetails]>> & AugmentedConst<ApiType>;
+            /**
+             * The number of blocks after submission that a referendum must begin being decided by.
+             * Once this passes, then anyone may cancel the referendum.
+             **/
+            undecidingTimeout: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        revive: {
+            /**
+             * The [EIP-155](https://eips.ethereum.org/EIPS/eip-155) chain ID.
+             *
+             * This is a unique identifier assigned to each blockchain network,
+             * preventing replay attacks.
+             **/
+            chainId: u64 & AugmentedConst<ApiType>;
+            /**
+             * The percentage of the storage deposit that should be held for using a code hash.
+             * Instantiating a contract, protects the code from being removed. In order to prevent
+             * abuse these actions are protected with a percentage of the code deposit.
+             **/
+            codeHashLockupDepositPercent: Perbill & AugmentedConst<ApiType>;
+            /**
+             * The amount of balance a caller has to pay for each byte of storage.
+             *
+             * # Note
+             *
+             * It is safe to change this value on a live chain as all refunds are pro rata.
+             **/
+            depositPerByte: u128 & AugmentedConst<ApiType>;
+            /**
+             * The amount of balance a caller has to pay for each storage item.
+             *
+             * # Note
+             *
+             * It is safe to change this value on a live chain as all refunds are pro rata.
+             **/
+            depositPerItem: u128 & AugmentedConst<ApiType>;
+            /**
+             * The ratio between the decimal representation of the native token and the ETH token.
+             **/
+            nativeToEthRatio: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: bool & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        safeMode: {
+            /**
+             * The amount that will be reserved upon calling [`Pallet::enter`].
+             *
+             * `None` disallows permissionlessly enabling the safe-mode and is a sane default.
+             **/
+            enterDepositAmount: Option<u128> & AugmentedConst<ApiType>;
+            /**
+             * For how many blocks the safe-mode will be entered by [`Pallet::enter`].
+             **/
+            enterDuration: u32 & AugmentedConst<ApiType>;
+            /**
+             * The amount that will be reserved upon calling [`Pallet::extend`].
+             *
+             * `None` disallows permissionlessly extending the safe-mode and is a sane default.
+             **/
+            extendDepositAmount: Option<u128> & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: Option<u32> & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        salary: {
+            /**
+             * The total budget per cycle.
+             *
+             * This may change over the course of a cycle without any problem.
+             **/
+            budget: u128 & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        scheduler: {
+            /**
+             * The maximum weight that may be scheduled per block for any dispatchables.
+             **/
+            maximumWeight: SpWeightsWeightV2Weight & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        society: {
+            /**
+             * The number of blocks between membership challenges.
+             **/
+            challengePeriod: u32 & AugmentedConst<ApiType>;
+            /**
+             * The number of blocks on which new candidates can claim their membership and be the
+             * named head.
+             **/
+            claimPeriod: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum number of strikes before a member gets funds slashed.
+             **/
+            graceStrikes: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum number of bids at once.
+             **/
+            maxBids: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum duration of the payout lock.
+             **/
+            maxLockDuration: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum number of payouts a member may have waiting unclaimed.
+             **/
+            maxPayouts: u32 & AugmentedConst<ApiType>;
+            /**
+             * The societies's pallet id
+             **/
+            palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
+            /**
+             * The amount of incentive paid within each period. Doesn't include VoterTip.
+             **/
+            periodSpend: u128 & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        staking: {
+            /**
+             * Number of eras that staked funds must remain bonded for.
+             **/
+            bondingDuration: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * Number of sessions per era.
+             **/
+            sessionsPerEra: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        statement: {
+            /**
+             * Cost of data byte used for priority calculation.
+             **/
+            byteCost: u128 & AugmentedConst<ApiType>;
+            /**
+             * Maximum data bytes allowed per account.
+             **/
+            maxAllowedBytes: u32 & AugmentedConst<ApiType>;
+            /**
+             * Maximum number of statements allowed per account.
+             **/
+            maxAllowedStatements: u32 & AugmentedConst<ApiType>;
+            /**
+             * Minimum data bytes allowed per account.
+             **/
+            minAllowedBytes: u32 & AugmentedConst<ApiType>;
+            /**
+             * Minimum number of statements allowed per account.
+             **/
+            minAllowedStatements: u32 & AugmentedConst<ApiType>;
+            /**
+             * Min balance for priority statements.
+             **/
+            statementCost: u128 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        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: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        system: {
+            /**
+             * Maximum number of block number to block hash mappings to keep (oldest pruned first).
+             **/
+            blockHashCount: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum length of a block (in bytes).
+             **/
+            blockLength: FrameSystemLimitsBlockLength & AugmentedConst<ApiType>;
+            /**
+             * Block & extrinsics weights: base values and limits.
+             **/
+            blockWeights: FrameSystemLimitsBlockWeights & AugmentedConst<ApiType>;
+            /**
+             * The weight of runtime database operations the runtime can invoke.
+             **/
+            dbWeight: SpWeightsRuntimeDbWeight & AugmentedConst<ApiType>;
+            /**
+             * 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: u16 & AugmentedConst<ApiType>;
+            /**
+             * Get the chain's in-code version.
+             **/
+            version: SpVersionRuntimeVersion & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        technicalCommittee: {
+            /**
+             * The maximum weight of a dispatch call that can be proposed and executed.
+             **/
+            maxProposalWeight: SpWeightsWeightV2Weight & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        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: u64 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        tips: {
+            /**
+             * The amount held on deposit per byte within the tip report reason or bounty description.
+             **/
+            dataDepositPerByte: u128 & AugmentedConst<ApiType>;
+            /**
+             * Maximum acceptable reason length.
+             *
+             * Benchmarks depend on this value, be sure to update weights file when changing this value
+             **/
+            maximumReasonLength: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum amount for a single tip.
+             **/
+            maxTipAmount: u128 & AugmentedConst<ApiType>;
+            /**
+             * The period for which a tip remains open after is has achieved threshold tippers.
+             **/
+            tipCountdown: u32 & AugmentedConst<ApiType>;
+            /**
+             * The percent of the final tip which goes to the original reporter of the tip.
+             **/
+            tipFindersFee: Percent & AugmentedConst<ApiType>;
+            /**
+             * The non-zero amount held on deposit for placing a tip report.
+             **/
+            tipReportDepositBase: u128 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        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: u8 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        treasury: {
+            /**
+             * Percentage of spare funds (if any) that are burnt per spend period.
+             **/
+            burn: Permill & AugmentedConst<ApiType>;
+            /**
+             * DEPRECATED: associated with `spend_local` call and will be removed in May 2025.
+             * Refer to <https://github.com/paritytech/polkadot-sdk/pull/5961> for migration to `spend`.
+             *
+             * 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: u32 & AugmentedConst<ApiType>;
+            /**
+             * The treasury's pallet id, used for deriving its sovereign account ID.
+             **/
+            palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
+            /**
+             * The period during which an approved treasury spend has to be claimed.
+             **/
+            payoutPeriod: u32 & AugmentedConst<ApiType>;
+            /**
+             * Gets this pallet's derived pot account.
+             **/
+            potAccount: AccountId32 & AugmentedConst<ApiType>;
+            /**
+             * Period between successive spends.
+             **/
+            spendPeriod: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        txPause: {
+            /**
+             * Maximum length for pallet name and call name SCALE encoded string names.
+             *
+             * TOO LONG NAMES WILL BE TREATED AS PAUSED.
+             **/
+            maxNameLen: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        uniques: {
+            /**
+             * The basic amount of funds that must be reserved when adding an attribute to an item.
+             **/
+            attributeDepositBase: u128 & AugmentedConst<ApiType>;
+            /**
+             * The basic amount of funds that must be reserved for collection.
+             **/
+            collectionDeposit: u128 & AugmentedConst<ApiType>;
+            /**
+             * The additional funds that must be reserved for the number of bytes store in metadata,
+             * either "normal" metadata or attribute metadata.
+             **/
+            depositPerByte: u128 & AugmentedConst<ApiType>;
+            /**
+             * The basic amount of funds that must be reserved for an item.
+             **/
+            itemDeposit: u128 & AugmentedConst<ApiType>;
+            /**
+             * The maximum length of an attribute key.
+             **/
+            keyLimit: u32 & AugmentedConst<ApiType>;
+            /**
+             * The basic amount of funds that must be reserved when adding metadata to your item.
+             **/
+            metadataDepositBase: u128 & AugmentedConst<ApiType>;
+            /**
+             * The maximum length of data stored on-chain.
+             **/
+            stringLimit: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum length of an attribute value.
+             **/
+            valueLimit: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        utility: {
+            /**
+             * The limit on the number of batched calls.
+             **/
+            batchedCallsLimit: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        vesting: {
+            maxVestingSchedules: u32 & AugmentedConst<ApiType>;
+            /**
+             * The minimum amount transferred to call `vested_transfer`.
+             **/
+            minVestedTransfer: u128 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        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: Vec<u64> & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+    }
+}