import type { ApiTypes } from '@polkadot/api-base/types';
import type { Option, Vec, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';
import type { Codec } from '@polkadot/types-codec/types';
import type { Permill } from '@polkadot/types/interfaces/runtime';
import type { FrameSupportPalletId, FrameSupportWeightsRuntimeDbWeight, FrameSupportWeightsWeightToFeeCoefficient, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, InterbtcPrimitivesCurrencyId, SpVersionRuntimeVersion, XcmV1MultiLocation } from '@polkadot/types/lookup';
declare module '@polkadot/api-base/types/consts' {
    interface AugmentedConsts<ApiType extends ApiTypes> {
        authorship: {
            /**
             * The number of blocks back we should accept uncles.
             * This means that we will deal with uncle-parents that are
             * `UncleGenerations + 1` before `now`.
             **/
            uncleGenerations: u32 & AugmentedConst<ApiType>;
            /**
             * Generic const
             **/
            [key: string]: Codec;
        };
        btcRelay: {
            parachainBlocksPerBitcoinBlock: u32 & AugmentedConst<ApiType>;
            /**
             * Generic const
             **/
            [key: string]: Codec;
        };
        currency: {
            /**
             * Native currency e.g. INTR/KINT
             **/
            getNativeCurrencyId: InterbtcPrimitivesCurrencyId & AugmentedConst<ApiType>;
            /**
             * Relay chain currency e.g. DOT/KSM
             **/
            getRelayChainCurrencyId: InterbtcPrimitivesCurrencyId & AugmentedConst<ApiType>;
            /**
             * Wrapped currency e.g. IBTC/KBTC
             **/
            getWrappedCurrencyId: InterbtcPrimitivesCurrencyId & AugmentedConst<ApiType>;
            /**
             * Generic const
             **/
            [key: string]: Codec;
        };
        democracy: {
            /**
             * The period between a proposal being approved and enacted.
             *
             * It should generally be a little more than the unstake period to ensure that
             * voting stakers have an opportunity to remove themselves from the system in the case
             * where they are on the losing side of a vote.
             **/
            enactmentPeriod: u32 & AugmentedConst<ApiType>;
            /**
             * Minimum voting period allowed for a fast-track referendum.
             **/
            fastTrackVotingPeriod: u32 & AugmentedConst<ApiType>;
            /**
             * How often (in blocks) new public referenda are launched.
             **/
            launchPeriod: 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.
             **/
            maxVotes: u32 & AugmentedConst<ApiType>;
            /**
             * The minimum amount to be used as a deposit for a public referendum proposal.
             **/
            minimumDeposit: u128 & AugmentedConst<ApiType>;
            /**
             * The amount of balance that must be deposited per byte of preimage stored.
             **/
            preimageByteDeposit: u128 & AugmentedConst<ApiType>;
            /**
             * How often (in blocks) to check for new votes.
             **/
            votingPeriod: u32 & AugmentedConst<ApiType>;
            /**
             * Generic const
             **/
            [key: string]: Codec;
        };
        escrow: {
            /**
             * The maximum time for locks.
             **/
            maxPeriod: u32 & AugmentedConst<ApiType>;
            /**
             * All future times are rounded by this.
             **/
            span: u32 & AugmentedConst<ApiType>;
            /**
             * Generic const
             **/
            [key: string]: Codec;
        };
        escrowAnnuity: {
            /**
             * The annuity module id, used for deriving its sovereign account ID.
             **/
            annuityPalletId: FrameSupportPalletId & AugmentedConst<ApiType>;
            /**
             * The emission period for block rewards.
             **/
            emissionPeriod: u32 & AugmentedConst<ApiType>;
            /**
             * Generic const
             **/
            [key: string]: Codec;
        };
        escrowRewards: {
            getNativeCurrencyId: InterbtcPrimitivesCurrencyId & AugmentedConst<ApiType>;
            getWrappedCurrencyId: InterbtcPrimitivesCurrencyId & AugmentedConst<ApiType>;
            /**
             * Generic const
             **/
            [key: string]: Codec;
        };
        fee: {
            /**
             * The fee module id, used for deriving its sovereign account ID.
             **/
            feePalletId: FrameSupportPalletId & 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 additional field for a registered identity.
             **/
            fieldDeposit: u128 & AugmentedConst<ApiType>;
            /**
             * Maximum number of additional fields that may be stored in an ID. Needed to bound the I/O
             * required to access an identity, but can be pretty high.
             **/
            maxAdditionalFields: u32 & AugmentedConst<ApiType>;
            /**
             * Maxmimum 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 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>;
            /**
             * 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: u16 & AugmentedConst<ApiType>;
            /**
             * Generic const
             **/
            [key: string]: Codec;
        };
        scheduler: {
            /**
             * The maximum weight that may be scheduled per block for any dispatchables of less
             * priority than `schedule::HARD_DEADLINE`.
             **/
            maximumWeight: u64 & AugmentedConst<ApiType>;
            /**
             * The maximum number of scheduled calls in the queue for a single block.
             * Not strictly enforced, but used for weight estimation.
             **/
            maxScheduledPerBlock: u32 & AugmentedConst<ApiType>;
            /**
             * Generic const
             **/
            [key: string]: Codec;
        };
        supply: {
            /**
             * The period between inflation updates.
             **/
            inflationPeriod: u32 & AugmentedConst<ApiType>;
            /**
             * The supply module id, used for deriving its sovereign account ID.
             **/
            supplyPalletId: FrameSupportPalletId & 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: FrameSupportWeightsRuntimeDbWeight & AugmentedConst<ApiType>;
            /**
             * The designated SS85 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 current version.
             **/
            version: SpVersionRuntimeVersion & AugmentedConst<ApiType>;
            /**
             * Generic const
             **/
            [key: string]: Codec;
        };
        timestamp: {
            /**
             * The minimum period between blocks. Beware 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. e.g. For Aura, it will be
             * double this period on default settings.
             **/
            minimumPeriod: u64 & AugmentedConst<ApiType>;
            /**
             * Generic const
             **/
            [key: string]: Codec;
        };
        tokens: {
            maxLocks: u32 & AugmentedConst<ApiType>;
            /**
             * Generic const
             **/
            [key: string]: Codec;
        };
        transactionPayment: {
            /**
             * The polynomial that is applied in order to derive fee from length.
             **/
            lengthToFee: Vec<FrameSupportWeightsWeightToFeeCoefficient> & AugmentedConst<ApiType>;
            /**
             * A fee mulitplier for `Operational` extrinsics to compute "virtual tip" to boost their
             * `priority`
             *
             * This value is multipled 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>;
            /**
             * The polynomial that is applied in order to derive fee from weight.
             **/
            weightToFee: Vec<FrameSupportWeightsWeightToFeeCoefficient> & AugmentedConst<ApiType>;
            /**
             * Generic const
             **/
            [key: string]: Codec;
        };
        treasury: {
            /**
             * Percentage of spare funds (if any) that are burnt per spend period.
             **/
            burn: Permill & AugmentedConst<ApiType>;
            /**
             * 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>;
            /**
             * Fraction of a proposal's value that should be bonded in order to place the proposal.
             * An accepted proposal gets these back. A rejected proposal does not.
             **/
            proposalBond: Permill & AugmentedConst<ApiType>;
            /**
             * Maximum amount of funds that should be placed in a deposit for making a proposal.
             **/
            proposalBondMaximum: Option<u128> & AugmentedConst<ApiType>;
            /**
             * Minimum amount of funds that should be placed in a deposit for making a proposal.
             **/
            proposalBondMinimum: u128 & AugmentedConst<ApiType>;
            /**
             * Period between successive spends.
             **/
            spendPeriod: 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;
        };
        vaultAnnuity: {
            /**
             * The annuity module id, used for deriving its sovereign account ID.
             **/
            annuityPalletId: FrameSupportPalletId & AugmentedConst<ApiType>;
            /**
             * The emission period for block rewards.
             **/
            emissionPeriod: u32 & AugmentedConst<ApiType>;
            /**
             * Generic const
             **/
            [key: string]: Codec;
        };
        vaultRegistry: {
            /**
             * Currency used for griefing collateral, e.g. DOT.
             **/
            getGriefingCollateralCurrencyId: InterbtcPrimitivesCurrencyId & AugmentedConst<ApiType>;
            /**
             * The vault module id, used for deriving its sovereign account ID.
             **/
            palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
            /**
             * Generic const
             **/
            [key: string]: Codec;
        };
        vaultRewards: {
            getNativeCurrencyId: InterbtcPrimitivesCurrencyId & AugmentedConst<ApiType>;
            getWrappedCurrencyId: InterbtcPrimitivesCurrencyId & AugmentedConst<ApiType>;
            /**
             * Generic const
             **/
            [key: string]: Codec;
        };
        vaultStaking: {
            getNativeCurrencyId: InterbtcPrimitivesCurrencyId & AugmentedConst<ApiType>;
            /**
             * Generic const
             **/
            [key: string]: Codec;
        };
        vesting: {
            /**
             * The minimum amount transferred to call `vested_transfer`.
             **/
            minVestedTransfer: u128 & AugmentedConst<ApiType>;
            /**
             * Generic const
             **/
            [key: string]: Codec;
        };
        xTokens: {
            /**
             * Base XCM weight.
             *
             * The actually weight for an XCM message is `T::BaseXcmWeight +
             * T::Weigher::weight(&msg)`.
             **/
            baseXcmWeight: u64 & AugmentedConst<ApiType>;
            /**
             * Self chain location.
             **/
            selfLocation: XcmV1MultiLocation & AugmentedConst<ApiType>;
            /**
             * Generic const
             **/
            [key: string]: Codec;
        };
    }
}
