import type { ApiTypes } from '@polkadot/api-base/types';
import type { Vec, u128, u16, u32, u64 } from '@polkadot/types-codec';
import type { Perbill, Permill } from '@polkadot/types/interfaces/runtime';
import type { FrameSupportWeightsRuntimeDbWeight, FrameSupportWeightsWeightToFeeCoefficient, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, PalletContractsSchedule, SpVersionRuntimeVersion } from "./types-lookup.ts";
declare module '@polkadot/api-base/types/consts' {
    interface AugmentedConsts<ApiType extends ApiTypes> {
        asset: {
            assetMetadataNameMaxLength: u32 & AugmentedConst<ApiType>;
            assetMetadataTypeDefMaxLength: u32 & AugmentedConst<ApiType>;
            assetMetadataValueMaxLength: u32 & AugmentedConst<ApiType>;
            assetNameMaxLength: u32 & AugmentedConst<ApiType>;
            fundingRoundNameMaxLength: u32 & AugmentedConst<ApiType>;
            maxNumberOfTMExtensionForAsset: u32 & AugmentedConst<ApiType>;
        };
        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>;
        };
        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>;
        };
        balances: {
            /**
             * The minimum amount required to keep an account open.
             **/
            existentialDeposit: u128 & AugmentedConst<ApiType>;
        };
        base: {
            maxLen: u32 & AugmentedConst<ApiType>;
        };
        complianceManager: {
            maxConditionComplexity: u32 & AugmentedConst<ApiType>;
        };
        contracts: {
            /**
             * The maximum number of contracts that can be pending for deletion.
             *
             * When a contract is deleted by calling `seal_terminate` it becomes inaccessible
             * immediately, but the deletion of the storage items it has accumulated is performed
             * later. The contract is put into the deletion queue. This defines how many
             * contracts can be queued up at the same time. If that limit is reached `seal_terminate`
             * will fail. The action must be retried in a later block in that case.
             *
             * The reasons for limiting the queue depth are:
             *
             * 1. The queue is in storage in order to be persistent between blocks. We want to limit
             * the amount of storage that can be consumed.
             * 2. The queue is stored in a vector and needs to be decoded as a whole when reading
             * it at the end of each block. Longer queues take more weight to decode and hence
             * limit the amount of items that can be deleted per block.
             **/
            deletionQueueDepth: u32 & AugmentedConst<ApiType>;
            /**
             * The maximum amount of weight that can be consumed per block for lazy trie removal.
             *
             * The amount of weight that is dedicated per block to work on the deletion queue. Larger
             * values allow more trie keys to be deleted in each block but reduce the amount of
             * weight that is left for transactions. See [`Self::DeletionQueueDepth`] for more
             * information about the deletion queue.
             **/
            deletionWeightLimit: u64 & 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>;
            /**
             * Cost schedule and limits.
             **/
            schedule: PalletContractsSchedule & AugmentedConst<ApiType>;
        };
        corporateAction: {
            maxDidWhts: u32 & AugmentedConst<ApiType>;
            maxTargetIds: u32 & AugmentedConst<ApiType>;
        };
        grandpa: {
            /**
             * Max Authorities in use
             **/
            maxAuthorities: u32 & AugmentedConst<ApiType>;
        };
        identity: {
            initialPOLYX: u128 & AugmentedConst<ApiType>;
        };
        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>;
        };
        indices: {
            /**
             * The deposit needed for reserving an index.
             **/
            deposit: u128 & AugmentedConst<ApiType>;
        };
        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>;
        };
        staking: {
            /**
             * Number of eras that staked funds must remain bonded for.
             **/
            bondingDuration: u32 & AugmentedConst<ApiType>;
            /**
             * The number of blocks before the end of the era from which election submissions are allowed.
             *
             * Setting this to zero will disable the offchain compute and only on-chain seq-phragmen will
             * be used.
             *
             * This is bounded by being within the last session. Hence, setting it to a value more than the
             * length of a session will be pointless.
             **/
            electionLookahead: u32 & AugmentedConst<ApiType>;
            /**
             * Total year rewards that gets paid during fixed reward schedule.
             **/
            fixedYearlyReward: u128 & AugmentedConst<ApiType>;
            /**
             * Maximum number of balancing iterations to run in the offchain submission.
             *
             * If set to 0, balance_solution will not be executed at all.
             **/
            maxIterations: u32 & AugmentedConst<ApiType>;
            /**
             * The maximum number of nominators rewarded for each validator.
             *
             * For each validator only the `$MaxNominatorRewardedPerValidator` biggest stakers can claim
             * their reward. This used to limit the i/o cost for the nominator payout.
             **/
            maxNominatorRewardedPerValidator: u32 & AugmentedConst<ApiType>;
            /**
             * Maximum number of validators for each permissioned identity.
             *
             * Max number of validators count = `MaxValidatorPerIdentity * Self::validator_count()`.
             **/
            maxValidatorPerIdentity: Permill & AugmentedConst<ApiType>;
            /**
             * Maximum amount of `T::currency::total_issuance()` after that non-inflated rewards get paid.
             **/
            maxVariableInflationTotalIssuance: u128 & AugmentedConst<ApiType>;
            /**
             * Minimum amount of POLYX that must be bonded for a new bond.
             **/
            minimumBond: u128 & AugmentedConst<ApiType>;
            /**
             * The threshold of improvement that should be provided for a new solution to be accepted.
             **/
            minSolutionScoreBump: Perbill & 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>;
        };
        statistics: {
            maxStatsPerAsset: u32 & AugmentedConst<ApiType>;
            maxTransferConditionsPerAsset: u32 & AugmentedConst<ApiType>;
        };
        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>;
        };
        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>;
        };
        transactionPayment: {
            /**
             * The fee to be paid for making a transaction; the per-byte portion.
             **/
            transactionByteFee: u128 & AugmentedConst<ApiType>;
            /**
             * The polynomial that is applied in order to derive fee from weight.
             **/
            weightToFee: Vec<FrameSupportWeightsWeightToFeeCoefficient> & AugmentedConst<ApiType>;
        };
    }
}
//# sourceMappingURL=augment-api-consts.d.ts.map