// Auto-generated via `yarn polkadot-types-from-chain`, do not edit
/* eslint-disable */

// import type lookup before we augment - in some environments
// this is required to allow for ambient/previous definitions
import '@pezkuwi/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 { PezframeSupportPezpalletId, PezframeSupportTokensFungibleUnionOfNativeOrWithId, PezframeSystemLimitsBlockLength, PezframeSystemLimitsBlockWeights, PezpalletContractsEnvironment, PezpalletContractsSchedule, PezpalletReferendaTrackDetails, PezspVersionRuntimeVersion, PezspWeightsRuntimeDbWeight, PezspWeightsWeightV2Weight } from '@pezkuwi/types/lookup';

export type __AugmentedConst<ApiType extends ApiTypes> = AugmentedConst<ApiType>;

declare module '@pezkuwi/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: PezspWeightsWeightV2Weight & 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: PezframeSupportPezpalletId & 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: PezframeSupportTokensFungibleUnionOfNativeOrWithId & 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: PezframeSupportPezpalletId & 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: PezframeSupportPezpalletId & 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: PezpalletContractsEnvironment & 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: PezpalletContractsSchedule & 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: PezspWeightsWeightV2Weight & AugmentedConst<ApiType>;
      /**
       * Generic const
       **/
      [key: string]: Codec;
    };
    delegatedStaking: {
      /**
       * Injected identifier for the pallet.
       **/
      palletId: PezframeSupportPezpalletId & 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: PezspWeightsWeightV2Weight & 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: PezspWeightsWeightV2Weight & 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: PezframeSupportPezpalletId & 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<PezspWeightsWeightV2Weight> & 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<PezspWeightsWeightV2Weight> & 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: PezframeSupportPezpalletId & 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: PezspWeightsWeightV2Weight & 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: PezframeSupportPezpalletId & 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: PezframeSupportPezpalletId & 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, PezpalletReferendaTrackDetails]>> & 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, PezpalletReferendaTrackDetails]>> & 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: PezspWeightsWeightV2Weight & 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: PezframeSupportPezpalletId & 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: PezframeSystemLimitsBlockLength & AugmentedConst<ApiType>;
      /**
       * Block & extrinsics weights: base values and limits.
       **/
      blockWeights: PezframeSystemLimitsBlockWeights & AugmentedConst<ApiType>;
      /**
       * The weight of runtime database operations the runtime can invoke.
       **/
      dbWeight: PezspWeightsRuntimeDbWeight & 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: PezspVersionRuntimeVersion & AugmentedConst<ApiType>;
      /**
       * Generic const
       **/
      [key: string]: Codec;
    };
    technicalCommittee: {
      /**
       * The maximum weight of a dispatch call that can be proposed and executed.
       **/
      maxProposalWeight: PezspWeightsWeightV2Weight & 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: PezframeSupportPezpalletId & 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;
    };
  } // AugmentedConsts
} // declare module
