import '@polkadot/api-base/types/consts';
import type { ApiTypes, AugmentedConst } from '@polkadot/api-base/types';
import type { bool, i128, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';
import type { ITuple } from '@polkadot/types-codec/types';
import type { Permill, Weight } from '@polkadot/types/interfaces/runtime';
import type { EqStakingStakePeriod, FrameSupportPalletId, FrameSupportWeightsRuntimeDbWeight, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, SpVersionRuntimeVersion } from '@polkadot/types/lookup';
export declare type __AugmentedConst<ApiType extends ApiTypes> = AugmentedConst<ApiType>;
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>;
        };
        bailsman: {
            /**
             * Amount of bailsmen to redistribute per block in offchain
             **/
            maxBailsmenToDistribute: u32 & AugmentedConst<ApiType>;
            /**
             * Minimum amount of balances account should have to register as bailsman
             **/
            minimalCollateral: u128 & AugmentedConst<ApiType>;
            /**
             * Minimal sum of the collateral and debt abs values to distribute temp Bailsman balances
             **/
            minTempBalanceUsd: u128 & AugmentedConst<ApiType>;
            /**
             * Pallet's AccountId for balances
             **/
            palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
            /**
             * Special constant for improving weight in unsigned extrinsics
             **/
            queueLengthWeightConstant: u32 & AugmentedConst<ApiType>;
            /**
             * Priority for offchain extrinsics
             **/
            unsignedPriority: u64 & AugmentedConst<ApiType>;
        };
        chainBridge: {
            /**
             * The identifier for this chain.
             * This must be unique and must not collide with existing IDs within a set of bridged chains.
             **/
            chainIdentity: u8 & AugmentedConst<ApiType>;
        };
        curveAmm: {
            /**
             * Anti ddos fee for pool creation
             **/
            creationFee: u128 & AugmentedConst<ApiType>;
            /**
             * Module account
             **/
            palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
        };
        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 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 amount of balance that must be deposited per byte of preimage stored.
             **/
            preimageByteDeposit: 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>;
        };
        eqAssets: {
            /**
             * Network native asset
             * Commissions are paid in this asset
             **/
            mainAsset: u64 & AugmentedConst<ApiType>;
        };
        eqBalances: {
            /**
             * Bailsman module's account
             **/
            bailsmanModuleId: FrameSupportPalletId & AugmentedConst<ApiType>;
            /**
             * Minimum account balance in usd. Accounts with deposit less than
             * `ExistentialDeposit` must be killed
             **/
            existentialDeposit: u128 & AugmentedConst<ApiType>;
            /**
             * Account for storing reserved balance
             **/
            moduleId: FrameSupportPalletId & AugmentedConst<ApiType>;
            /**
             * Treasury module's account
             **/
            treasuryModuleId: FrameSupportPalletId & AugmentedConst<ApiType>;
        };
        eqDex: {
            /**
             * Used for calculation unsigned transaction priority
             **/
            dexUnsignedPriority: u64 & AugmentedConst<ApiType>;
            /**
             * Fee for deleting orders by offchain worker
             **/
            penaltyFee: u128 & AugmentedConst<ApiType>;
            /**
             * Used for group orders in chunks. Should be positive value
             **/
            priceStepCount: u32 & AugmentedConst<ApiType>;
        };
        eqInvestors: {
            /**
             * Pallet's AccountId for balance
             **/
            palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
        };
        eqLending: {
            /**
             * Lending pool ModuleId
             **/
            moduleId: FrameSupportPalletId & AugmentedConst<ApiType>;
        };
        eqLiquidityFarming: {
            /**
             * Pallet's AccountId for balance
             **/
            palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
        };
        eqLockdrop: {
            /**
             * Used for calculation unsigned transaction priority
             **/
            lockDropUnsignedPriority: u64 & AugmentedConst<ApiType>;
            /**
             * Period of lock program in seconds
             **/
            lockPeriod: u64 & AugmentedConst<ApiType>;
            /**
             * Minimum amount to lock
             **/
            minLockAmount: u128 & AugmentedConst<ApiType>;
            /**
             * Pallet's AccountId for balances
             **/
            palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
        };
        eqMarginCall: {
            /**
             * `critical_margin` setting, when the margin is below this value, a position is liquidated immediately
             **/
            criticalMargin: u128 & AugmentedConst<ApiType>;
            /**
             * `initial_margin` setting, when the margin is below this value, borrowing is prohibited
             **/
            initialMargin: u128 & AugmentedConst<ApiType>;
            /**
             * `maintenance_margin` setting, when the margin is below this value, a MaintenanceMarginCall event is fired
             **/
            maintenanceMargin: u128 & AugmentedConst<ApiType>;
            /**
             * `maintenance_period` setting, a time period (in seconds) when the margin account can be topped up to the `initial_margin` setting to avoid a margin call
             **/
            maintenancePeriod: u64 & AugmentedConst<ApiType>;
        };
        eqMultisigSudo: {
            /**
             * Maximal number of signatories
             **/
            maxSignatories: u32 & AugmentedConst<ApiType>;
        };
        eqRate: {
            /**
             * Pricing model scaling factor
             **/
            alpha: i128 & AugmentedConst<ApiType>;
            /**
             * Gets bailsman module account for margincall and fee transfers
             **/
            bailsmanModuleId: FrameSupportPalletId & AugmentedConst<ApiType>;
            /**
             * Base bailsman fee
             **/
            baseBailsmanFee: Permill & AugmentedConst<ApiType>;
            /**
             * Base lender fee
             **/
            baseLenderFee: Permill & AugmentedConst<ApiType>;
            /**
             * Lender part of prime rate
             **/
            lenderPart: Permill & AugmentedConst<ApiType>;
            /**
             * For transferring fee to lending pool
             **/
            lendingModuleId: FrameSupportPalletId & AugmentedConst<ApiType>;
            /**
             * Minimum new debt for system reinit
             **/
            minSurplus: u128 & AugmentedConst<ApiType>;
            /**
             * Minimum temp bailsmen balances for Bailsman pallet reinit
             **/
            minTempBailsman: u128 & AugmentedConst<ApiType>;
            /**
             * Lower bound for scaling risk model
             **/
            riskLowerBound: i128 & AugmentedConst<ApiType>;
            /**
             * Number of standard deviations to consider when stress testing
             **/
            riskNSigma: i128 & AugmentedConst<ApiType>;
            /**
             * Upper bound for scaling risk model
             **/
            riskUpperBound: i128 & AugmentedConst<ApiType>;
            /**
             * Treasury fee rate
             **/
            treasuryFee: Permill & AugmentedConst<ApiType>;
            /**
             * For transferring fee to treasury
             **/
            treasuryModuleId: FrameSupportPalletId & AugmentedConst<ApiType>;
            /**
             * For unsigned transaction priority calculation
             **/
            unsignedPriority: u64 & AugmentedConst<ApiType>;
            /**
             * Fee part that stays in Treasury pallet
             **/
            weightFeeTreasury: u32 & AugmentedConst<ApiType>;
            /**
             * Fee part that goes to validator
             **/
            weightFeeValidator: u32 & AugmentedConst<ApiType>;
        };
        eqStaking: {
            /**
             * Max number of stakes for single account
             **/
            maxStakesCount: u32 & AugmentedConst<ApiType>;
            rewardsLockPeriod: EqStakingStakePeriod & AugmentedConst<ApiType>;
        };
        eqTreasury: {
            /**
             * Pallet's AccountId for balance
             **/
            palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
        };
        eqWrappedDot: {
            /**
             * Maximum reservation coefficient that can possibly be observed
             * If reservation coefficient exceeds that value, `balance_staking` will balance it to `TargetReserve`
             **/
            maxReserve: Permill & AugmentedConst<ApiType>;
            /**
             * Min amount to deposit, by default 5 DOT
             **/
            minDeposit: u128 & AugmentedConst<ApiType>;
            /**
             * Minimum reservation coefficient that can possibly be observed
             * If reservation coefficient falls below that value, `balance_staking` will balance it to `TargetReserve`
             **/
            minReserve: Permill & AugmentedConst<ApiType>;
            /**
             * Pallet identifier
             **/
            palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
            parachainId: u32 & AugmentedConst<ApiType>;
            /**
             * Reservation coefficient that is preferable, with deviation in range [`MinReserve`, `MaxReserve`]
             **/
            targetReserve: Permill & AugmentedConst<ApiType>;
            /**
             * Fee payed for withdraw, also used in price calculation, by default 0.98940904738
             **/
            withdrawFee: Permill & AugmentedConst<ApiType>;
        };
        financial: {
            priceCount: u32 & AugmentedConst<ApiType>;
            pricePeriod: u32 & AugmentedConst<ApiType>;
        };
        migration: {
            /**
             * Set storage calls per block
             **/
            migrationsPerBlock: u16 & AugmentedConst<ApiType>;
        };
        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>;
        };
        oracle: {
            /**
             * Time between recalculation assets financial data in ms
             **/
            financialRecalcPeriodBlocks: u32 & AugmentedConst<ApiType>;
            /**
             * Pallet setting representing amount of time for which price median is valid
             **/
            medianPriceTimeout: u64 & AugmentedConst<ApiType>;
            /**
             * Pallet setting representing amount of time for which price point is valid
             **/
            priceTimeout: u64 & AugmentedConst<ApiType>;
            /**
             * Lifetime in blocks for unsigned transactions
             **/
            unsignedLifetimeInBlocks: u32 & AugmentedConst<ApiType>;
            /**
             * For priority calculation of an unsigned transaction
             **/
            unsignedPriority: ITuple<[u64, u64]> & AugmentedConst<ApiType>;
        };
        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>;
        };
        republic: {
            /**
             * Pallet's AccountId for balance
             **/
            palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
        };
        scheduler: {
            /**
             * The maximum weight that may be scheduled per block for any dispatchables of less
             * priority than `schedule::HARD_DEADLINE`.
             **/
            maximumWeight: Weight & 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>;
        };
        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 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 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: {
            /**
             * 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>;
        };
        treasury: {
            /**
             * Fee from collateral buyouts (any currency that is not basic asset)
             **/
            buyFee: Permill & AugmentedConst<ApiType>;
            /**
             * Min amount of native token to buyout
             **/
            minAmountToBuyout: u128 & AugmentedConst<ApiType>;
            /**
             * Fee from the basic asset buyouts
             **/
            sellFee: Permill & AugmentedConst<ApiType>;
        };
        utility: {
            /**
             * The limit on the number of batched calls.
             **/
            batchedCallsLimit: u32 & AugmentedConst<ApiType>;
        };
        vesting: {
            /**
             * The minimum amount transferred to call `vested_transfer`
             **/
            minVestedTransfer: u128 & AugmentedConst<ApiType>;
            palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
        };
        vesting2: {
            /**
             * The minimum amount transferred to call `vested_transfer`
             **/
            minVestedTransfer: u128 & AugmentedConst<ApiType>;
            palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
        };
    }
}
