import '@polkadot/api-base/types/submittable';
import type { ApiTypes, AugmentedSubmittable, SubmittableExtrinsic, SubmittableExtrinsicFunction } from '@polkadot/api-base/types';
import type { Data } from '@polkadot/types';
import type { Bytes, Compact, Option, U256, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';
import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types';
import type { AccountId32, Call, H160, H256, Permill } from '@polkadot/types/interfaces/runtime';
import type { BitcoinAddress, BitcoinAddressPublicKey, BitcoinBlockHeader, BitcoinFullTransactionProof, ClientsInfoClientRelease, CumulusPrimitivesParachainInherentParachainInherentData, DemocracyVote, DexSwapRouterRoute, EthereumTransactionTransactionV2, FrameSupportPreimagesBounded, InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCustomMetadata, InterbtcPrimitivesOracleKey, InterbtcPrimitivesVaultCurrencyPair, InterbtcPrimitivesVaultId, InterlayRuntimeParachainOriginCaller, InterlayRuntimeParachainProxyType, InterlayRuntimeParachainSessionKeys, LoansMarket, LoansRateModelInterestRateModel, OrmlTraitsAssetRegistryAssetMetadata, OrmlVestingVestingSchedule, PalletIdentityBitFlags, PalletIdentityIdentityInfo, PalletIdentityJudgement, PalletMultisigTimepoint, SpWeightsWeightV2Weight, XcmV3MultiLocation, XcmV3WeightLimit, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';
export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;
export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;
export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;
declare module '@polkadot/api-base/types/submittable' {
    interface AugmentedSubmittables<ApiType extends ApiTypes> {
        assetRegistry: {
            registerAsset: AugmentedSubmittable<(metadata: OrmlTraitsAssetRegistryAssetMetadata | {
                decimals?: any;
                name?: any;
                symbol?: any;
                existentialDeposit?: any;
                location?: any;
                additional?: any;
            } | string | Uint8Array, assetId: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [OrmlTraitsAssetRegistryAssetMetadata, Option<u32>]>;
            updateAsset: AugmentedSubmittable<(assetId: u32 | AnyNumber | Uint8Array, decimals: Option<u32> | null | Uint8Array | u32 | AnyNumber, name: Option<Bytes> | null | Uint8Array | Bytes | string, symbol: Option<Bytes> | null | Uint8Array | Bytes | string, existentialDeposit: Option<u128> | null | Uint8Array | u128 | AnyNumber, location: Option<Option<XcmVersionedMultiLocation>> | null | Uint8Array | Option<XcmVersionedMultiLocation> | XcmVersionedMultiLocation | {
                V2: any;
            } | {
                V3: any;
            } | string, additional: Option<InterbtcPrimitivesCustomMetadata> | null | Uint8Array | InterbtcPrimitivesCustomMetadata | {
                feePerSecond?: any;
                coingeckoId?: any;
            } | string) => SubmittableExtrinsic<ApiType>, [u32, Option<u32>, Option<Bytes>, Option<Bytes>, Option<u128>, Option<Option<XcmVersionedMultiLocation>>, Option<InterbtcPrimitivesCustomMetadata>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        baseFee: {
            setBaseFeePerGas: AugmentedSubmittable<(fee: U256 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [U256]>;
            setElasticity: AugmentedSubmittable<(elasticity: Permill | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Permill]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        btcRelay: {
            /**
             * One time function to initialize the BTC-Relay with the first block
             *
             * # Arguments
             *
             * * `block_header` - Bitcoin block header.
             * * `block_height` - starting Bitcoin block height of the submitted block header.
             *
             * ## Complexity
             * - O(1)
             **/
            initialize: AugmentedSubmittable<(blockHeader: BitcoinBlockHeader | {
                merkleRoot?: any;
                target?: any;
                timestamp?: any;
                version?: any;
                hash_?: any;
                hashPrevBlock?: any;
                nonce?: any;
            } | string | Uint8Array, blockHeight: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [BitcoinBlockHeader, u32]>;
            /**
             * Stores a single new block header
             *
             * # Arguments
             *
             * * `block_header` - Bitcoin block header.
             *
             * ## Complexity
             * - `O(F)` where `F` is the number of forks
             **/
            storeBlockHeader: AugmentedSubmittable<(blockHeader: BitcoinBlockHeader | {
                merkleRoot?: any;
                target?: any;
                timestamp?: any;
                version?: any;
                hash_?: any;
                hashPrevBlock?: any;
                nonce?: any;
            } | string | Uint8Array, forkBound: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [BitcoinBlockHeader, u32]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        clientsInfo: {
            /**
             * Sets the current client release version, in case of a bug fix or patch.
             * Clients include the vault, oracle, and faucet.
             *
             * # Arguments
             * * `client_name` - raw byte string representation of the client name (e.g. `b"vault"`, `b"oracle"`,
             * `b"faucet"`)
             * * `release` - The release information for the given `client_name`
             **/
            setCurrentClientRelease: AugmentedSubmittable<(clientName: Bytes | string | Uint8Array, release: ClientsInfoClientRelease | {
                uri?: any;
                checksum?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, ClientsInfoClientRelease]>;
            /**
             * Sets the pending client release version. To be batched alongside the
             * `parachainSystem.authorizeUpgrade` Cumulus call.
             * Clients include the vault, oracle, and faucet.
             *
             * # Arguments
             * * `client_name` - raw byte string representation of the client name (e.g. `b"vault"`, `b"oracle"`,
             * `b"faucet"`)
             * * `release` - The release information for the given `client_name`
             **/
            setPendingClientRelease: AugmentedSubmittable<(clientName: Bytes | string | Uint8Array, release: ClientsInfoClientRelease | {
                uri?: any;
                checksum?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, ClientsInfoClientRelease]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        collatorSelection: {
            /**
             * Deregister `origin` as a collator candidate. Note that the collator can only leave on
             * session change. The `CandidacyBond` will be unreserved immediately.
             *
             * This call will fail if the total number of candidates would drop below `MinCandidates`.
             *
             * This call is not available to `Invulnerable` collators.
             **/
            leaveIntent: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Register this account as a collator candidate. The account must (a) already have
             * registered session keys and (b) be able to reserve the `CandidacyBond`.
             *
             * This call is not available to `Invulnerable` collators.
             **/
            registerAsCandidate: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Set the candidacy bond amount.
             **/
            setCandidacyBond: AugmentedSubmittable<(bond: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;
            /**
             * Set the ideal number of collators (not including the invulnerables).
             * If lowering this number, then the number of running collators could be higher than this figure.
             * Aside from that edge case, there should be no other way to have more collators than the desired number.
             **/
            setDesiredCandidates: AugmentedSubmittable<(max: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
            /**
             * Set the list of invulnerable (fixed) collators.
             **/
            setInvulnerables: AugmentedSubmittable<(updated: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        cumulusXcm: {
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        democracy: {
            /**
             * Remove a proposal.
             *
             * - `prop_index`: The index of the proposal to cancel.
             *
             * Weight: `O(p)` where `p = PublicProps::<T>::decode_len()`
             **/
            cancelProposal: AugmentedSubmittable<(propIndex: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;
            /**
             * Remove a referendum.
             *
             * The dispatch origin of this call must be _Root_.
             *
             * - `ref_index`: The index of the referendum to cancel.
             *
             * # Weight: `O(1)`.
             **/
            cancelReferendum: AugmentedSubmittable<(refIndex: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;
            /**
             * Clears all public proposals.
             *
             * The dispatch origin of this call must be _Root_.
             *
             * Weight: `O(1)`.
             **/
            clearPublicProposals: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Schedule a proposal to be tabled immediately with the `FastTrackVotingPeriod`.
             *
             * The dispatch of this call must be `FastTrackOrigin`.
             *
             * - `prop_index`: The index of the current external proposal.
             * - `delay`: The number of blocks to wait after approval before execution.
             *
             * Emits `Started` and `FastTrack`.
             *
             * Weight: `O(1)`
             **/
            fastTrack: AugmentedSubmittable<(propIndex: Compact<u32> | AnyNumber | Uint8Array, delay: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, u32]>;
            /**
             * Reduces the voting period of an existing referendum.
             *
             * The dispatch of this call must be `FastTrackOrigin`.
             *
             * - `ref_index`: The index of the referendum.
             *
             * Emits `FastTrackReferendum`.
             *
             * Weight: `O(1)`
             **/
            fastTrackReferendum: AugmentedSubmittable<(refIndex: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;
            /**
             * Propose a sensitive action to be taken.
             *
             * The dispatch origin of this call must be _Signed_ and the sender must
             * have funds to cover the deposit.
             *
             * - `proposal_hash`: The hash of the proposal preimage.
             * - `value`: The amount of deposit (must be at least `MinimumDeposit`).
             *
             * Emits `Proposed`.
             *
             * Weight: `O(p)`
             **/
            propose: AugmentedSubmittable<(proposal: FrameSupportPreimagesBounded | {
                Legacy: any;
            } | {
                Inline: any;
            } | {
                Lookup: any;
            } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [FrameSupportPreimagesBounded, Compact<u128>]>;
            /**
             * Remove a vote for an ongoing referendum.
             *
             * The dispatch origin of this call must be _Signed_, and the signer must have a vote
             * registered for referendum `index`.
             *
             * - `index`: The index of referendum of the vote to be removed.
             *
             * Weight: `O(R + log R)` where R is the number of referenda that `target` has voted on.
             * Weight is calculated for the maximum number of vote.
             **/
            removeVote: AugmentedSubmittable<(index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
            /**
             * Signals agreement with a particular proposal.
             *
             * The dispatch origin of this call must be _Signed_ and the sender
             * must have funds to cover the deposit, equal to the original deposit.
             *
             * - `proposal`: The index of the proposal to second.
             * - `seconds_upper_bound`: an upper bound on the current number of seconds on this proposal. Extrinsic is
             * weighted according to this value with no refund.
             *
             * Weight: `O(S)` where S is the number of seconds a proposal already has.
             **/
            second: AugmentedSubmittable<(proposal: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;
            spendFromTreasury: AugmentedSubmittable<(value: Compact<u128> | AnyNumber | Uint8Array, beneficiary: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u128>, AccountId32]>;
            /**
             * Same as `fast_track` but with the default `VotingPeriod`.
             *
             * The dispatch of this call must be `FastTrackOrigin`.
             *
             * - `prop_index`: The index of the proposal.
             * - `delay`: The number of blocks to wait after approval before execution.
             *
             * Emits `Started` and `FastTrack`.
             *
             * Weight: `O(1)`
             **/
            tableProposal: AugmentedSubmittable<(propIndex: Compact<u32> | AnyNumber | Uint8Array, delay: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, u32]>;
            /**
             * Vote in a referendum. If `vote.is_aye()`, the vote is to enact the proposal;
             * otherwise it is a vote to keep the status quo.
             *
             * The dispatch origin of this call must be _Signed_.
             *
             * - `ref_index`: The index of the referendum to vote for.
             * - `vote`: The vote configuration.
             *
             * Weight: `O(R)` where R is the number of referendums the voter has voted on.
             **/
            vote: AugmentedSubmittable<(refIndex: Compact<u32> | AnyNumber | Uint8Array, vote: DemocracyVote | {
                aye?: any;
                balance?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, DemocracyVote]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        dexGeneral: {
            /**
             * Provide liquidity to a pair.
             *
             * The order of assets does not effect the result.
             *
             * # Arguments
             *
             * - `asset_0`: Asset which make up pair
             * - `asset_1`: Asset which make up pair
             * - `amount_0_desired`: Maximum amount of asset_0 added to the pair
             * - `amount_1_desired`: Maximum amount of asset_1 added to the pair
             * - `amount_0_min`: Minimum amount of asset_0 added to the pair
             * - `amount_1_min`: Minimum amount of asset_1 added to the pair
             * - `deadline`: Height of the cutoff block of this transaction
             **/
            addLiquidity: AugmentedSubmittable<(asset0: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, asset1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, amount0Desired: Compact<u128> | AnyNumber | Uint8Array, amount1Desired: Compact<u128> | AnyNumber | Uint8Array, amount0Min: Compact<u128> | AnyNumber | Uint8Array, amount1Min: Compact<u128> | AnyNumber | Uint8Array, deadline: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId, Compact<u128>, Compact<u128>, Compact<u128>, Compact<u128>, Compact<u32>]>;
            bootstrapChargeReward: AugmentedSubmittable<(asset0: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, asset1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, chargeRewards: Vec<ITuple<[InterbtcPrimitivesCurrencyId, u128]>> | ([InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, u128 | AnyNumber | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId, Vec<ITuple<[InterbtcPrimitivesCurrencyId, u128]>>]>;
            /**
             * Claim lp asset from a bootstrap pair
             *
             * # Arguments
             *
             * - `asset_0`: Asset which make up bootstrap pair
             * - `asset_1`: Asset which make up bootstrap pair
             * - `deadline`: Height of the cutoff block of this transaction
             **/
            bootstrapClaim: AugmentedSubmittable<(recipient: AccountId32 | string | Uint8Array, asset0: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, asset1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, deadline: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId, Compact<u32>]>;
            /**
             * Contribute some asset to a bootstrap pair
             *
             * # Arguments
             *
             * - `asset_0`: Asset which make up bootstrap pair
             * - `asset_1`: Asset which make up bootstrap pair
             * - `amount_0_contribute`: The amount of asset_0 contribute to this bootstrap pair
             * - `amount_1_contribute`: The amount of asset_1 contribute to this bootstrap pair
             * - `deadline`: Height of the cutoff block of this transaction
             **/
            bootstrapContribute: AugmentedSubmittable<(asset0: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, asset1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, amount0Contribute: Compact<u128> | AnyNumber | Uint8Array, amount1Contribute: Compact<u128> | AnyNumber | Uint8Array, deadline: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId, Compact<u128>, Compact<u128>, Compact<u32>]>;
            /**
             * Create bootstrap pair
             *
             * The order of asset don't affect result.
             *
             * # Arguments
             *
             * - `asset_0`: Asset which make up bootstrap pair
             * - `asset_1`: Asset which make up bootstrap pair
             * - `target_supply_0`: Target amount of asset_0 total contribute
             * - `target_supply_0`: Target amount of asset_1 total contribute
             * - `capacity_supply_0`: The max amount of asset_0 total contribute
             * - `capacity_supply_1`: The max amount of asset_1 total contribute
             * - `end`: The earliest ending block.
             **/
            bootstrapCreate: AugmentedSubmittable<(asset0: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, asset1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, targetSupply0: Compact<u128> | AnyNumber | Uint8Array, targetSupply1: Compact<u128> | AnyNumber | Uint8Array, capacitySupply0: Compact<u128> | AnyNumber | Uint8Array, capacitySupply1: Compact<u128> | AnyNumber | Uint8Array, end: Compact<u32> | AnyNumber | Uint8Array, rewards: Vec<InterbtcPrimitivesCurrencyId> | (InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array)[], limits: Vec<ITuple<[InterbtcPrimitivesCurrencyId, u128]>> | ([InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, u128 | AnyNumber | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId, Compact<u128>, Compact<u128>, Compact<u128>, Compact<u128>, Compact<u32>, Vec<InterbtcPrimitivesCurrencyId>, Vec<ITuple<[InterbtcPrimitivesCurrencyId, u128]>>]>;
            /**
             * End a bootstrap pair
             *
             * # Arguments
             *
             * - `asset_0`: Asset which make up bootstrap pair
             * - `asset_1`: Asset which make up bootstrap pair
             **/
            bootstrapEnd: AugmentedSubmittable<(asset0: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, asset1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]>;
            /**
             * Contributor refund from disable bootstrap pair
             *
             * # Arguments
             *
             * - `asset_0`: Asset which make up bootstrap pair
             * - `asset_1`: Asset which make up bootstrap pair
             **/
            bootstrapRefund: AugmentedSubmittable<(asset0: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, asset1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]>;
            /**
             * update a bootstrap pair
             *
             * # Arguments
             *
             * - `asset_0`: Asset which make up bootstrap pair
             * - `asset_1`: Asset which make up bootstrap pair
             * - `min_contribution_0`: The new min amount of asset_0 contribute
             * - `min_contribution_0`: The new min amount of asset_1 contribute
             * - `target_supply_0`: The new target amount of asset_0 total contribute
             * - `target_supply_0`: The new target amount of asset_1 total contribute
             * - `capacity_supply_0`: The new max amount of asset_0 total contribute
             * - `capacity_supply_1`: The new max amount of asset_1 total contribute
             * - `end`: The earliest ending block.
             **/
            bootstrapUpdate: AugmentedSubmittable<(asset0: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, asset1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, targetSupply0: Compact<u128> | AnyNumber | Uint8Array, targetSupply1: Compact<u128> | AnyNumber | Uint8Array, capacitySupply0: Compact<u128> | AnyNumber | Uint8Array, capacitySupply1: Compact<u128> | AnyNumber | Uint8Array, end: Compact<u32> | AnyNumber | Uint8Array, rewards: Vec<InterbtcPrimitivesCurrencyId> | (InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array)[], limits: Vec<ITuple<[InterbtcPrimitivesCurrencyId, u128]>> | ([InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, u128 | AnyNumber | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId, Compact<u128>, Compact<u128>, Compact<u128>, Compact<u128>, Compact<u32>, Vec<InterbtcPrimitivesCurrencyId>, Vec<ITuple<[InterbtcPrimitivesCurrencyId, u128]>>]>;
            bootstrapWithdrawReward: AugmentedSubmittable<(asset0: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, asset1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, recipient: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId, AccountId32]>;
            /**
             * Create pair by two assets.
             *
             * The order of assets does not effect the result.
             *
             * # Arguments
             *
             * - `asset_0`: Asset which make up Pair
             * - `asset_1`: Asset which make up Pair
             **/
            createPair: AugmentedSubmittable<(asset0: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, asset1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, feeRate: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId, u128]>;
            /**
             * Extract liquidity.
             *
             * The order of assets does not effect the result.
             *
             * # Arguments
             *
             * - `asset_0`: Asset which make up pair
             * - `asset_1`: Asset which make up pair
             * - `amount_asset_0_min`: Minimum amount of asset_0 to exact
             * - `amount_asset_1_min`: Minimum amount of asset_1 to exact
             * - `recipient`: Account that accepts withdrawal of assets
             * - `deadline`: Height of the cutoff block of this transaction
             **/
            removeLiquidity: AugmentedSubmittable<(asset0: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, asset1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, liquidity: Compact<u128> | AnyNumber | Uint8Array, amount0Min: Compact<u128> | AnyNumber | Uint8Array, amount1Min: Compact<u128> | AnyNumber | Uint8Array, recipient: AccountId32 | string | Uint8Array, deadline: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId, Compact<u128>, Compact<u128>, Compact<u128>, AccountId32, Compact<u32>]>;
            /**
             * Set the exchange fee rate.
             *
             * # Arguments
             *
             * - `asset_0`: Asset which makes up the pair
             * - `asset_1`: Asset which makes up the pair
             * - `fee_rate`:
             * Value denoting the trading fee taken from the amount paid in,
             * multiplied by the fee adjustment to simplify calculations.
             * e.g. 0.3% / 100 = 0.003
             * 0.003 * 10000 = 30
             * See section 3.2.1 of the Uniswap v2 whitepaper
             **/
            setExchangeFee: AugmentedSubmittable<(asset0: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, asset1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, feeRate: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId, u128]>;
            /**
             * Set the protocol fee point.
             *
             * # Arguments
             *
             * - `fee_point`:
             * An integer y which satisfies the equation `1/x-1=y`
             * where x is the percentage of the exchange fee
             * e.g. 1/(1/6)-1=5, 1/(1/2)-1=1
             * See section 2.4 of the Uniswap v2 whitepaper
             **/
            setFeePoint: AugmentedSubmittable<(feePoint: u8 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u8]>;
            /**
             * Set the new receiver of the protocol fee.
             *
             * # Arguments
             *
             * - `send_to`:
             * (1) Some(receiver): it turn on the protocol fee and the new receiver account.
             * (2) None: it turn off the protocol fee.
             **/
            setFeeReceiver: AugmentedSubmittable<(sendTo: Option<AccountId32> | null | Uint8Array | AccountId32 | string) => SubmittableExtrinsic<ApiType>, [Option<AccountId32>]>;
            /**
             * Buy amount of asset by path.
             *
             * # Arguments
             *
             * - `amount_out`: Amount of the asset will be bought
             * - `amount_in_max`: Maximum amount of sold asset
             * - `path`: path can convert to pairs.
             * - `recipient`: Account that receive the target asset
             * - `deadline`: Height of the cutoff block of this transaction
             **/
            swapAssetsForExactAssets: AugmentedSubmittable<(amountOut: Compact<u128> | AnyNumber | Uint8Array, amountInMax: Compact<u128> | AnyNumber | Uint8Array, path: Vec<InterbtcPrimitivesCurrencyId> | (InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array)[], recipient: AccountId32 | string | Uint8Array, deadline: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u128>, Compact<u128>, Vec<InterbtcPrimitivesCurrencyId>, AccountId32, Compact<u32>]>;
            /**
             * Sell amount of asset by path.
             *
             * # Arguments
             *
             * - `amount_in`: Amount of the asset will be sold
             * - `amount_out_min`: Minimum amount of target asset
             * - `path`: path can convert to pairs.
             * - `recipient`: Account that receive the target asset
             * - `deadline`: Height of the cutoff block of this transaction
             **/
            swapExactAssetsForAssets: AugmentedSubmittable<(amountIn: Compact<u128> | AnyNumber | Uint8Array, amountOutMin: Compact<u128> | AnyNumber | Uint8Array, path: Vec<InterbtcPrimitivesCurrencyId> | (InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array)[], recipient: AccountId32 | string | Uint8Array, deadline: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u128>, Compact<u128>, Vec<InterbtcPrimitivesCurrencyId>, AccountId32, Compact<u32>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        dexStable: {
            /**
             * Supply amounts of currencies to the pool.
             *
             * # Argument
             *
             * - `pool_id`: The id of pool.
             * - `amounts`: Supply amounts of currencies.
             * - `min_mint_amount`: The min amount of lp currency get.
             * - `deadline`: Height of the cutoff block of this transaction
             **/
            addLiquidity: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array, amounts: Vec<u128> | (u128 | AnyNumber | Uint8Array)[], minMintAmount: u128 | AnyNumber | Uint8Array, to: AccountId32 | string | Uint8Array, deadline: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, Vec<u128>, u128, AccountId32, u32]>;
            /**
             * Supply amounts of currencies to the pool which contains the lp currency of the base
             * pool.
             *
             * # Argument
             *
             * - `pool_id`: The id of pool.
             * - `base_pool_id`: The id of base pool.
             * - `meta_amounts`: Supply amounts of currencies to pool. The last element must be zero.
             * - `base_amounts`: Supply amounts of currencies to base pool.
             * - `min_to_mint`: The min amount of pool lp currency get.
             * - `deadline`: Height of the cutoff block of this transaction.
             **/
            addPoolAndBasePoolLiquidity: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array, basePoolId: u32 | AnyNumber | Uint8Array, metaAmounts: Vec<u128> | (u128 | AnyNumber | Uint8Array)[], baseAmounts: Vec<u128> | (u128 | AnyNumber | Uint8Array)[], minToMint: u128 | AnyNumber | Uint8Array, to: AccountId32 | string | Uint8Array, deadline: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<u128>, Vec<u128>, u128, AccountId32, u32]>;
            /**
             * Create a stable amm pool.
             *
             * Only admin can create pool.
             *
             * # Argument
             *
             * - `currency_ids`: The currencies will be join the created pool.
             * - `currency_decimals`: The currencies corresponding decimals.
             * - `lp_currency_id`: The specify lp currency id of the created pool.
             * - `a`: The initial A of created pool.
             * - `fee`: The swap fee of created pool.
             * - `admin_fee`: The admin fee of created pool.
             * - `admin_fee_receiver`: The admin fee receiver of created pool.
             * - `lp_currency_symbol`: The symbol of created pool lp currency.
             * - `lp_currency_decimal`: The decimal of created pool lp currency.
             **/
            createBasePool: AugmentedSubmittable<(currencyIds: Vec<InterbtcPrimitivesCurrencyId> | (InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array)[], currencyDecimals: Vec<u32> | (u32 | AnyNumber | Uint8Array)[], a: u128 | AnyNumber | Uint8Array, fee: u128 | AnyNumber | Uint8Array, adminFee: u128 | AnyNumber | Uint8Array, adminFeeReceiver: AccountId32 | string | Uint8Array, lpCurrencySymbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<InterbtcPrimitivesCurrencyId>, Vec<u32>, u128, u128, u128, AccountId32, Bytes]>;
            /**
             * Create a stable amm meta pool.
             *
             * Only admin can create pool.
             *
             * # Argument
             *
             * - `currency_ids`: The currencies will be join the created pool.
             * - `currency_decimals`: The currencies corresponding decimals.
             * - `lp_currency_id`: The specify lp currency id of the created pool.
             * - `a`: The initial A of created pool.
             * - `fee`: The swap fee of created pool.
             * - `admin_fee`: The admin fee of created pool.
             * - `admin_fee_receiver`: The admin fee receiver of created pool.
             * - `lp_currency_symbol`: The symbol of created pool lp currency.
             * - `lp_currency_decimal`: The decimal of created pool lp currency.
             **/
            createMetaPool: AugmentedSubmittable<(currencyIds: Vec<InterbtcPrimitivesCurrencyId> | (InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array)[], currencyDecimals: Vec<u32> | (u32 | AnyNumber | Uint8Array)[], a: u128 | AnyNumber | Uint8Array, fee: u128 | AnyNumber | Uint8Array, adminFee: u128 | AnyNumber | Uint8Array, adminFeeReceiver: AccountId32 | string | Uint8Array, lpCurrencySymbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<InterbtcPrimitivesCurrencyId>, Vec<u32>, u128, u128, u128, AccountId32, Bytes]>;
            /**
             * Start ramping up or down A parameter towards given future_a and future_a_time
             *
             * Only called by admin.
             * Checks if the change is too rapid, and commits the new A value only when it falls under
             * the limit range.
             *
             * # Argument
             *
             * - `pool_id`: The id of pool.
             * - `future_a`: The new A to ramp towards.
             * - `future_a_time`: Timestamp when the new A should be reached
             **/
            rampA: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array, futureA: u128 | AnyNumber | Uint8Array, futureATime: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u128, u128]>;
            /**
             * Remove liquidity from a pool.
             *
             * # Argument
             *
             * - `pool_id`: The id of pool.
             * - `lp_amount`: The amounts of lp currency.
             * - `min_amounts`: The min amounts of pool's currencies to get.
             * - `deadline`: Height of the cutoff block of this transaction
             **/
            removeLiquidity: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array, lpAmount: u128 | AnyNumber | Uint8Array, minAmounts: Vec<u128> | (u128 | AnyNumber | Uint8Array)[], to: AccountId32 | string | Uint8Array, deadline: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u128, Vec<u128>, AccountId32, u32]>;
            /**
             * Remove liquidity from a pool to the specify amounts of currencies.
             *
             * # Argument
             *
             * - `pool_id`: The id of pool.
             * - `amounts`: The specify amounts of receive currencies.
             * - `max_burn_amount`: The max amount of burned lp currency.
             * - `deadline`: Height of the cutoff block of this transaction
             **/
            removeLiquidityImbalance: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array, amounts: Vec<u128> | (u128 | AnyNumber | Uint8Array)[], maxBurnAmount: u128 | AnyNumber | Uint8Array, to: AccountId32 | string | Uint8Array, deadline: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, Vec<u128>, u128, AccountId32, u32]>;
            /**
             * Remove liquidity from a pool to get one currency.
             *
             * # Argument
             *
             * - `pool_id`: The id of pool.
             * - `lp_amount`: The amounts of lp currency.
             * - `index`: The index of receive currency.
             * - `min_amount`: The min amounts of received currency;
             * - `deadline`: Height of the cutoff block of this transaction
             **/
            removeLiquidityOneCurrency: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array, lpAmount: u128 | AnyNumber | Uint8Array, index: u32 | AnyNumber | Uint8Array, minAmount: u128 | AnyNumber | Uint8Array, to: AccountId32 | string | Uint8Array, deadline: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u128, u32, u128, AccountId32, u32]>;
            /**
             * Remove liquidity from a pool which contains the lp currency of the base pool.
             *
             * # Argument
             *
             * - `pool_id`: The id of pool.
             * - `base_pool_id`: The id of base pool.
             * - `amount`: The amounts of lp currency to burn.
             * - `min_amounts_meta`: The min amounts of pool's currencies to get.
             * - `min_amounts_base`: The min amounts of basic pool's currencies to get.
             * - `deadline`: Height of the cutoff block of this transaction.
             **/
            removePoolAndBasePoolLiquidity: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array, basePoolId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array, minAmountsMeta: Vec<u128> | (u128 | AnyNumber | Uint8Array)[], minAmountsBase: Vec<u128> | (u128 | AnyNumber | Uint8Array)[], to: AccountId32 | string | Uint8Array, deadline: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128, Vec<u128>, Vec<u128>, AccountId32, u32]>;
            /**
             * Remove liquidity from a pool which contains the lp currency of the base pool
             * to get one currency.
             *
             * # Argument
             *
             * - `pool_id`: The id of pool.
             * - `base_pool_id`: The id of base pool.
             * - `amount`: The amounts of lp currency to burn.
             * - `i`: The index of target currency in basic pool.
             * - `min_amount`: The min amounts of received currency.
             * - `deadline`: Height of the cutoff block of this transaction.
             **/
            removePoolAndBasePoolLiquidityOneCurrency: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array, basePoolId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array, i: u32 | AnyNumber | Uint8Array, minAmount: u128 | AnyNumber | Uint8Array, to: AccountId32 | string | Uint8Array, deadline: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128, u32, u128, AccountId32, u32]>;
            /**
             * Update admin fee of the pool.
             *
             * Only called by admin.
             *
             * # Argument
             *
             * - `pool_id`: The id of pool.
             * - `new_admin_fee`: The new admin fee of this pool.
             **/
            setAdminFee: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array, newAdminFee: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u128]>;
            /**
             * Update fee of the pool.
             *
             * Only called by admin.
             *
             * # Argument
             *
             * - `pool_id`: The id of pool.
             * - `new_swap_fee`: The new swap fee of this pool.
             **/
            setSwapFee: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array, newSwapFee: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u128]>;
            /**
             * Stop ramping A parameter.
             *
             * Only called by admin.
             *
             * # Argument
             *
             * - `pool_id`: The id of pool.
             **/
            stopRampA: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
            /**
             * Swap a amounts of currencies to get other.
             *
             * # Argument
             *
             * - `pool_id`: The id of pool.
             * - `from_index`: The index of swap currency id.
             * - `to_index`: The index of receive currency id.
             * - `in_amount`: The amounts of currencies swap.
             * - `min_mint_amount`: The min amount of receive currency.
             * - `deadline`: Height of the cutoff block of this transaction
             **/
            swap: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array, fromIndex: u32 | AnyNumber | Uint8Array, toIndex: u32 | AnyNumber | Uint8Array, inAmount: u128 | AnyNumber | Uint8Array, minOutAmount: u128 | AnyNumber | Uint8Array, to: AccountId32 | string | Uint8Array, deadline: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32, u128, u128, AccountId32, u32]>;
            swapMetaPoolUnderlying: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array, inIndex: u32 | AnyNumber | Uint8Array, outIndex: u32 | AnyNumber | Uint8Array, dx: u128 | AnyNumber | Uint8Array, minDy: u128 | AnyNumber | Uint8Array, to: AccountId32 | string | Uint8Array, deadline: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32, u128, u128, AccountId32, u32]>;
            /**
             * Swap the currency from basic pool to get amounts of other currency in pool.
             * to get one currency.
             *
             * # Argument
             *
             * - `pool_id`: The id of pool.
             * - `base_pool_id`: The id of base pool.
             * - `in_index`: The index of swap currency in basic pool.
             * - `out_index`: The index of target currency in pool.
             * - `dx`: The amounts of swap currency.
             * - `min_dy`: The min amounts of target currency.
             * - `deadline`: Height of the cutoff block of this transaction.
             **/
            swapPoolFromBase: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array, basePoolId: u32 | AnyNumber | Uint8Array, inIndex: u32 | AnyNumber | Uint8Array, outIndex: u32 | AnyNumber | Uint8Array, dx: u128 | AnyNumber | Uint8Array, minDy: u128 | AnyNumber | Uint8Array, to: AccountId32 | string | Uint8Array, deadline: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32, u32, u128, u128, AccountId32, u32]>;
            /**
             * Swap the currency from pool to get amounts of other currency in basic pool.
             * to get one currency.
             *
             * # Argument
             *
             * - `pool_id`: The id of pool.
             * - `base_pool_id`: The id of base pool.
             * - `in_index`: The index of swap currency in basic pool.
             * - `out_index`: The index of target currency in pool.
             * - `dx`: The amounts of swap currency.
             * - `min_dy`: The min amounts of target currency.
             * - `deadline`: Height of the cutoff block of this transaction.
             **/
            swapPoolToBase: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array, basePoolId: u32 | AnyNumber | Uint8Array, inIndex: u32 | AnyNumber | Uint8Array, outIndex: u32 | AnyNumber | Uint8Array, dx: u128 | AnyNumber | Uint8Array, minDy: u128 | AnyNumber | Uint8Array, to: AccountId32 | string | Uint8Array, deadline: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32, u32, u128, u128, AccountId32, u32]>;
            /**
             * Update admin fee receiver of the pool.
             *
             * Only called by admin.
             *
             * # Argument
             *
             * - `pool_id`: The id of pool.
             * - `fee_receiver`: The new admin fee receiver of this pool.
             **/
            updateFeeReceiver: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array, feeReceiver: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;
            /**
             * Withdraw the admin fee from pool to admin fee receiver.
             *
             * Can called by anyone.
             *
             * # Argument
             *
             * - `pool_id`: The id of pool.
             **/
            withdrawAdminFee: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        dexSwapRouter: {
            /**
             * Atomically execute a series of trades using `DexGeneral` and/or `DexStable`.
             * The whole transaction will rollback if any of the trades fail.
             *
             * ## Complexity
             * - O(T) where T is the number of trades.
             **/
            swapExactTokensForTokens: AugmentedSubmittable<(amountIn: u128 | AnyNumber | Uint8Array, amountOutMin: u128 | AnyNumber | Uint8Array, routes: Vec<DexSwapRouterRoute> | (DexSwapRouterRoute | {
                General: any;
            } | {
                Stable: any;
            } | string | Uint8Array)[], to: AccountId32 | string | Uint8Array, deadline: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128, u128, Vec<DexSwapRouterRoute>, AccountId32, u32]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        dmpQueue: {
            /**
             * Service a single overweight message.
             **/
            serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: SpWeightsWeightV2Weight | {
                refTime?: any;
                proofSize?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, SpWeightsWeightV2Weight]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        escrow: {
            createLock: AugmentedSubmittable<(amount: Compact<u128> | AnyNumber | Uint8Array, unlockHeight: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u128>, u32]>;
            increaseAmount: AugmentedSubmittable<(amount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u128>]>;
            increaseUnlockHeight: AugmentedSubmittable<(unlockHeight: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
            setAccountBlock: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;
            setAccountLimit: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array, start: u32 | AnyNumber | Uint8Array, end: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, u32, u32]>;
            /**
             * Update the stake amount for a user.
             *
             * # Arguments
             *
             * * `origin` - Sender of the transaction.
             * * `target_user` - The account ID of the user whose stake amount needs to be updated.
             **/
            updateUserStake: AugmentedSubmittable<(targetUser: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;
            withdraw: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        escrowAnnuity: {
            setRewardPerWrapped: AugmentedSubmittable<(rewardPerWrapped: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;
            updateRewards: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            withdrawRewards: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        ethereum: {
            /**
             * Transact an Ethereum transaction.
             **/
            transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | {
                Legacy: any;
            } | {
                EIP2930: any;
            } | {
                EIP1559: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        evm: {
            /**
             * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.
             **/
            call: AugmentedSubmittable<(source: H160 | string | Uint8Array, target: H160 | string | Uint8Array, input: Bytes | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, maxFeePerGas: U256 | AnyNumber | Uint8Array, maxPriorityFeePerGas: Option<U256> | null | Uint8Array | U256 | AnyNumber, nonce: Option<U256> | null | Uint8Array | U256 | AnyNumber, accessList: Vec<ITuple<[H160, Vec<H256>]>> | ([H160 | string | Uint8Array, Vec<H256> | (H256 | string | Uint8Array)[]])[]) => SubmittableExtrinsic<ApiType>, [H160, H160, Bytes, U256, u64, U256, Option<U256>, Option<U256>, Vec<ITuple<[H160, Vec<H256>]>>]>;
            /**
             * Issue an EVM create operation. This is similar to a contract creation transaction in
             * Ethereum.
             **/
            create: AugmentedSubmittable<(source: H160 | string | Uint8Array, init: Bytes | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, maxFeePerGas: U256 | AnyNumber | Uint8Array, maxPriorityFeePerGas: Option<U256> | null | Uint8Array | U256 | AnyNumber, nonce: Option<U256> | null | Uint8Array | U256 | AnyNumber, accessList: Vec<ITuple<[H160, Vec<H256>]>> | ([H160 | string | Uint8Array, Vec<H256> | (H256 | string | Uint8Array)[]])[]) => SubmittableExtrinsic<ApiType>, [H160, Bytes, U256, u64, U256, Option<U256>, Option<U256>, Vec<ITuple<[H160, Vec<H256>]>>]>;
            /**
             * Issue an EVM create2 operation.
             **/
            create2: AugmentedSubmittable<(source: H160 | string | Uint8Array, init: Bytes | string | Uint8Array, salt: H256 | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, maxFeePerGas: U256 | AnyNumber | Uint8Array, maxPriorityFeePerGas: Option<U256> | null | Uint8Array | U256 | AnyNumber, nonce: Option<U256> | null | Uint8Array | U256 | AnyNumber, accessList: Vec<ITuple<[H160, Vec<H256>]>> | ([H160 | string | Uint8Array, Vec<H256> | (H256 | string | Uint8Array)[]])[]) => SubmittableExtrinsic<ApiType>, [H160, Bytes, H256, U256, u64, U256, Option<U256>, Option<U256>, Vec<ITuple<[H160, Vec<H256>]>>]>;
            /**
             * Withdraw balance from EVM into currency/balances pallet.
             **/
            withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        farming: {
            /**
             * Withdraw any accrued rewards from the reward pool
             **/
            claim: AugmentedSubmittable<(poolCurrencyId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, rewardCurrencyId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]>;
            /**
             * Stake all pool tokens in the reward pool
             *
             * - `pool_currency_id`: LP token to deposit
             * - `length_rewards`: upper bound for number of reward currencies
             **/
            deposit: AugmentedSubmittable<(poolCurrencyId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, lengthRewards: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, u32]>;
            /**
             * Explicitly remove a reward schedule and transfer any remaining
             * balance to the treasury
             **/
            removeRewardSchedule: AugmentedSubmittable<(poolCurrencyId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, rewardCurrencyId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]>;
            /**
             * Create or overwrite the reward schedule, if a reward schedule
             * already exists for the rewards currency the duration is added
             * to the existing duration and the rewards per period are modified
             * s.t. that the total (old remaining + new) rewards are distributed
             * over the new total duration
             **/
            updateRewardSchedule: AugmentedSubmittable<(poolCurrencyId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, rewardCurrencyId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, periodCount: u32 | AnyNumber | Uint8Array, amount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId, u32, Compact<u128>]>;
            /**
             * Unstake the pool tokens from the reward pool
             *
             * - `pool_currency_id`: LP token to withdraw
             * - `amount`: of LP token to withdraw
             * - `length_rewards`: upper bound for number of reward currencies
             **/
            withdraw: AugmentedSubmittable<(poolCurrencyId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array, lengthRewards: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, u128, u32]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        fee: {
            /**
             * todo: proper weight
             **/
            setCommission: AugmentedSubmittable<(currencies: InterbtcPrimitivesVaultCurrencyPair | {
                collateral?: any;
                wrapped?: any;
            } | string | Uint8Array, commission: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesVaultCurrencyPair, u128]>;
            /**
             * Changes the issue fee percentage (only executable by the Root account)
             *
             * # Arguments
             *
             * * `origin` - signing account
             * * `fee` - the new fee
             **/
            setIssueFee: AugmentedSubmittable<(fee: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;
            /**
             * Changes the issue griefing collateral percentage (only executable by the Root account)
             *
             * # Arguments
             *
             * * `origin` - signing account
             * * `griefing_collateral` - the new griefing collateral
             **/
            setIssueGriefingCollateral: AugmentedSubmittable<(griefingCollateral: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;
            /**
             * Changes the premium redeem fee percentage (only executable by the Root account)
             *
             * # Arguments
             *
             * * `origin` - signing account
             * * `fee` - the new fee
             **/
            setPremiumRedeemFee: AugmentedSubmittable<(fee: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;
            /**
             * Changes the punishment fee percentage (only executable by the Root account)
             *
             * # Arguments
             *
             * * `origin` - signing account
             * * `fee` - the new fee
             **/
            setPunishmentFee: AugmentedSubmittable<(fee: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;
            /**
             * Changes the redeem fee percentage (only executable by the Root account)
             *
             * # Arguments
             *
             * * `origin` - signing account
             * * `fee` - the new fee
             **/
            setRedeemFee: AugmentedSubmittable<(fee: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;
            /**
             * Changes the replace griefing collateral percentage (only executable by the Root account)
             *
             * # Arguments
             *
             * * `origin` - signing account
             * * `griefing_collateral` - the new griefing collateral
             **/
            setReplaceGriefingCollateral: AugmentedSubmittable<(griefingCollateral: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;
            /**
             * Withdraw all rewards from the `origin` account in the `vault_id` staking pool.
             *
             * # Arguments
             *
             * * `origin` - signing account
             **/
            withdrawRewards: AugmentedSubmittable<(vaultId: InterbtcPrimitivesVaultId | {
                accountId?: any;
                currencies?: any;
            } | string | Uint8Array, index: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesVaultId, Option<u32>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        identity: {
            /**
             * Add a registrar to the system.
             *
             * The dispatch origin for this call must be `T::RegistrarOrigin`.
             *
             * - `account`: the account of the registrar.
             *
             * Emits `RegistrarAdded` if successful.
             *
             * ## Complexity
             * - `O(R)` where `R` registrar-count (governance-bounded and code-bounded).
             **/
            addRegistrar: AugmentedSubmittable<(account: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;
            /**
             * Add the given account to the sender's subs.
             *
             * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated
             * to the sender.
             *
             * The dispatch origin for this call must be _Signed_ and the sender must have a registered
             * sub identity of `sub`.
             **/
            addSub: AugmentedSubmittable<(sub: AccountId32 | string | Uint8Array, data: Data | {
                None: any;
            } | {
                Raw: any;
            } | {
                BlakeTwo256: any;
            } | {
                Sha256: any;
            } | {
                Keccak256: any;
            } | {
                ShaThree256: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, Data]>;
            /**
             * Cancel a previous request.
             *
             * Payment: A previously reserved deposit is returned on success.
             *
             * The dispatch origin for this call must be _Signed_ and the sender must have a
             * registered identity.
             *
             * - `reg_index`: The index of the registrar whose judgement is no longer requested.
             *
             * Emits `JudgementUnrequested` if successful.
             *
             * ## Complexity
             * - `O(R + X)`.
             * - where `R` registrar-count (governance-bounded).
             * - where `X` additional-field-count (deposit-bounded and code-bounded).
             **/
            cancelRequest: AugmentedSubmittable<(regIndex: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
            /**
             * Clear an account's identity info and all sub-accounts and return all deposits.
             *
             * Payment: All reserved balances on the account are returned.
             *
             * The dispatch origin for this call must be _Signed_ and the sender must have a registered
             * identity.
             *
             * Emits `IdentityCleared` if successful.
             *
             * ## Complexity
             * - `O(R + S + X)`
             * - where `R` registrar-count (governance-bounded).
             * - where `S` subs-count (hard- and deposit-bounded).
             * - where `X` additional-field-count (deposit-bounded and code-bounded).
             **/
            clearIdentity: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Remove an account's identity and sub-account information and slash the deposits.
             *
             * Payment: Reserved balances from `set_subs` and `set_identity` are slashed and handled by
             * `Slash`. Verification request deposits are not returned; they should be cancelled
             * manually using `cancel_request`.
             *
             * The dispatch origin for this call must match `T::ForceOrigin`.
             *
             * - `target`: the account whose identity the judgement is upon. This must be an account
             * with a registered identity.
             *
             * Emits `IdentityKilled` if successful.
             *
             * ## Complexity
             * - `O(R + S + X)`
             * - where `R` registrar-count (governance-bounded).
             * - where `S` subs-count (hard- and deposit-bounded).
             * - where `X` additional-field-count (deposit-bounded and code-bounded).
             **/
            killIdentity: AugmentedSubmittable<(target: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;
            /**
             * Provide a judgement for an account's identity.
             *
             * The dispatch origin for this call must be _Signed_ and the sender must be the account
             * of the registrar whose index is `reg_index`.
             *
             * - `reg_index`: the index of the registrar whose judgement is being made.
             * - `target`: the account whose identity the judgement is upon. This must be an account
             * with a registered identity.
             * - `judgement`: the judgement of the registrar of index `reg_index` about `target`.
             * - `identity`: The hash of the [`IdentityInfo`] for that the judgement is provided.
             *
             * Emits `JudgementGiven` if successful.
             *
             * ## Complexity
             * - `O(R + X)`.
             * - where `R` registrar-count (governance-bounded).
             * - where `X` additional-field-count (deposit-bounded and code-bounded).
             **/
            provideJudgement: AugmentedSubmittable<(regIndex: Compact<u32> | AnyNumber | Uint8Array, target: AccountId32 | string | Uint8Array, judgement: PalletIdentityJudgement | {
                Unknown: any;
            } | {
                FeePaid: any;
            } | {
                Reasonable: any;
            } | {
                KnownGood: any;
            } | {
                OutOfDate: any;
            } | {
                LowQuality: any;
            } | {
                Erroneous: any;
            } | string | Uint8Array, identity: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, AccountId32, PalletIdentityJudgement, H256]>;
            /**
             * Remove the sender as a sub-account.
             *
             * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated
             * to the sender (*not* the original depositor).
             *
             * The dispatch origin for this call must be _Signed_ and the sender must have a registered
             * super-identity.
             *
             * NOTE: This should not normally be used, but is provided in the case that the non-
             * controller of an account is maliciously registered as a sub-account.
             **/
            quitSub: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Remove the given account from the sender's subs.
             *
             * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated
             * to the sender.
             *
             * The dispatch origin for this call must be _Signed_ and the sender must have a registered
             * sub identity of `sub`.
             **/
            removeSub: AugmentedSubmittable<(sub: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;
            /**
             * Alter the associated name of the given sub-account.
             *
             * The dispatch origin for this call must be _Signed_ and the sender must have a registered
             * sub identity of `sub`.
             **/
            renameSub: AugmentedSubmittable<(sub: AccountId32 | string | Uint8Array, data: Data | {
                None: any;
            } | {
                Raw: any;
            } | {
                BlakeTwo256: any;
            } | {
                Sha256: any;
            } | {
                Keccak256: any;
            } | {
                ShaThree256: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, Data]>;
            /**
             * Request a judgement from a registrar.
             *
             * Payment: At most `max_fee` will be reserved for payment to the registrar if judgement
             * given.
             *
             * The dispatch origin for this call must be _Signed_ and the sender must have a
             * registered identity.
             *
             * - `reg_index`: The index of the registrar whose judgement is requested.
             * - `max_fee`: The maximum fee that may be paid. This should just be auto-populated as:
             *
             * ```nocompile
             * Self::registrars().get(reg_index).unwrap().fee
             * ```
             *
             * Emits `JudgementRequested` if successful.
             *
             * ## Complexity
             * - `O(R + X)`.
             * - where `R` registrar-count (governance-bounded).
             * - where `X` additional-field-count (deposit-bounded and code-bounded).
             **/
            requestJudgement: AugmentedSubmittable<(regIndex: Compact<u32> | AnyNumber | Uint8Array, maxFee: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Compact<u128>]>;
            /**
             * Change the account associated with a registrar.
             *
             * The dispatch origin for this call must be _Signed_ and the sender must be the account
             * of the registrar whose index is `index`.
             *
             * - `index`: the index of the registrar whose fee is to be set.
             * - `new`: the new account ID.
             *
             * ## Complexity
             * - `O(R)`.
             * - where `R` registrar-count (governance-bounded).
             **/
            setAccountId: AugmentedSubmittable<(index: Compact<u32> | AnyNumber | Uint8Array, updated: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, AccountId32]>;
            /**
             * Set the fee required for a judgement to be requested from a registrar.
             *
             * The dispatch origin for this call must be _Signed_ and the sender must be the account
             * of the registrar whose index is `index`.
             *
             * - `index`: the index of the registrar whose fee is to be set.
             * - `fee`: the new fee.
             *
             * ## Complexity
             * - `O(R)`.
             * - where `R` registrar-count (governance-bounded).
             **/
            setFee: AugmentedSubmittable<(index: Compact<u32> | AnyNumber | Uint8Array, fee: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Compact<u128>]>;
            /**
             * Set the field information for a registrar.
             *
             * The dispatch origin for this call must be _Signed_ and the sender must be the account
             * of the registrar whose index is `index`.
             *
             * - `index`: the index of the registrar whose fee is to be set.
             * - `fields`: the fields that the registrar concerns themselves with.
             *
             * ## Complexity
             * - `O(R)`.
             * - where `R` registrar-count (governance-bounded).
             **/
            setFields: AugmentedSubmittable<(index: Compact<u32> | AnyNumber | Uint8Array, fields: PalletIdentityBitFlags) => SubmittableExtrinsic<ApiType>, [Compact<u32>, PalletIdentityBitFlags]>;
            /**
             * Set an account's identity information and reserve the appropriate deposit.
             *
             * If the account already has identity information, the deposit is taken as part payment
             * for the new deposit.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * - `info`: The identity information.
             *
             * Emits `IdentitySet` if successful.
             *
             * ## Complexity
             * - `O(X + X' + R)`
             * - where `X` additional-field-count (deposit-bounded and code-bounded)
             * - where `R` judgements-count (registrar-count-bounded)
             **/
            setIdentity: AugmentedSubmittable<(info: PalletIdentityIdentityInfo | {
                additional?: any;
                display?: any;
                legal?: any;
                web?: any;
                riot?: any;
                email?: any;
                pgpFingerprint?: any;
                image?: any;
                twitter?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletIdentityIdentityInfo]>;
            /**
             * Set the sub-accounts of the sender.
             *
             * Payment: Any aggregate balance reserved by previous `set_subs` calls will be returned
             * and an amount `SubAccountDeposit` will be reserved for each item in `subs`.
             *
             * The dispatch origin for this call must be _Signed_ and the sender must have a registered
             * identity.
             *
             * - `subs`: The identity's (new) sub-accounts.
             *
             * ## Complexity
             * - `O(P + S)`
             * - where `P` old-subs-count (hard- and deposit-bounded).
             * - where `S` subs-count (hard- and deposit-bounded).
             **/
            setSubs: AugmentedSubmittable<(subs: Vec<ITuple<[AccountId32, Data]>> | ([AccountId32 | string | Uint8Array, Data | {
                None: any;
            } | {
                Raw: any;
            } | {
                BlakeTwo256: any;
            } | {
                Sha256: any;
            } | {
                Keccak256: any;
            } | {
                ShaThree256: any;
            } | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[AccountId32, Data]>>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        issue: {
            /**
             * Cancel the issuance of tokens if expired
             *
             * # Arguments
             *
             * * `origin` - sender of the transaction
             * * `issue_id` - identifier of issue request as output from request_issue
             **/
            cancelIssue: AugmentedSubmittable<(issueId: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;
            /**
             * Finalize the issuance of tokens
             *
             * # Arguments
             *
             * * `origin` - sender of the transaction
             * * `issue_id` - identifier of issue request as output from request_issue
             * * `tx_block_height` - block number of collateral chain
             * * `merkle_proof` - raw bytes
             * * `raw_tx` - raw bytes
             **/
            executeIssue: AugmentedSubmittable<(issueId: H256 | string | Uint8Array, uncheckedTransaction: BitcoinFullTransactionProof | {
                userTxProof?: any;
                coinbaseProof?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, BitcoinFullTransactionProof]>;
            /**
             * Request the issuance of tokens
             *
             * # Arguments
             *
             * * `origin` - sender of the transaction
             * * `amount` - amount of BTC the user wants to convert to issued tokens. Note that the
             * amount of issued tokens received will be less, because a fee is subtracted.
             * * `vault` - address of the vault
             * * `griefing_collateral` - amount of collateral
             **/
            requestIssue: AugmentedSubmittable<(amount: Compact<u128> | AnyNumber | Uint8Array, vaultId: InterbtcPrimitivesVaultId | {
                accountId?: any;
                currencies?: any;
            } | string | Uint8Array, griefingCurrency: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u128>, InterbtcPrimitivesVaultId, InterbtcPrimitivesCurrencyId]>;
            /**
             * Set the default issue period for tx verification.
             *
             * # Arguments
             *
             * * `origin` - the dispatch origin of this call (must be _Root_)
             * * `period` - default period for new requests
             *
             * # Weight: `O(1)`
             **/
            setIssuePeriod: AugmentedSubmittable<(period: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        loans: {
            /**
             * Activates a market. Returns `Err` if the market does not exist.
             *
             * If the market is already active, does nothing.
             *
             * - `asset_id`: Currency to enable lending and borrowing for.
             **/
            activateMarket: AugmentedSubmittable<(assetId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId]>;
            /**
             * Creates a new lending market for a given currency. Returns `Err` if a market already
             * exists for the given currency.
             *
             * All provided market states must be `Pending`, otherwise an error will be returned.
             *
             * The lend_token id specified in the Market struct has to be unique, and cannot be later reused
             * when creating a new market.
             *
             * - `asset_id`: Currency to enable lending and borrowing for.
             * - `market`: Configuration of the new lending market
             **/
            addMarket: AugmentedSubmittable<(assetId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, market: LoansMarket | {
                collateralFactor?: any;
                liquidationThreshold?: any;
                reserveFactor?: any;
                closeFactor?: any;
                liquidateIncentive?: any;
                liquidateIncentiveReservedFactor?: any;
                rateModel?: any;
                state?: any;
                supplyCap?: any;
                borrowCap?: any;
                lendTokenId?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, LoansMarket]>;
            /**
             * Add reserves by transferring from payer.
             * TODO: This extrinsic currently does nothing useful. See the TODO comment
             * of the `ensure_enough_cash` function for more details. Based on that
             * TODO, decide whether this extrinsic should be kept.
             *
             * May only be called from `T::ReserveOrigin`.
             *
             * - `payer`: the payer account.
             * - `asset_id`: the assets to be added.
             * - `add_amount`: the amount to be added.
             **/
            addReserves: AugmentedSubmittable<(payer: AccountId32 | string | Uint8Array, assetId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, addAmount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, InterbtcPrimitivesCurrencyId, Compact<u128>]>;
            /**
             * Deposit incentive reward currency into the pallet account.
             *
             * - `amount`: Reward amount added
             **/
            addReward: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;
            /**
             * The caller borrows `borrow_amount` of `asset_id` from the protocol, using their
             * supplied assets as collateral.
             *
             * - `asset_id`: the asset to be borrowed.
             * - `borrow_amount`: the amount to be borrowed.
             **/
            borrow: AugmentedSubmittable<(assetId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, borrowAmount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, Compact<u128>]>;
            /**
             * Claim incentive rewards for all markets.
             **/
            claimReward: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Claim inceitve reward for the specified market.
             *
             * - `asset_id`: Market related currency
             **/
            claimRewardForMarket: AugmentedSubmittable<(assetId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId]>;
            /**
             * Caller enables their lend token balance as borrow collateral. This operation locks
             * the lend tokens, so they are no longer transferrable.
             * Any incoming lend tokens into the caller's account (either by direct transfer or minting)
             * are automatically locked as well, such that locking and unlocking borrow collateral is
             * an atomic state (a "collateral toggle").
             * If any of the caller's lend token balance is locked elsewhere (for instance, as bridge vault
             * collateral), this operation will fail.
             * If this operation is successful, the caller's maximum allowed debt increases.
             *
             * - `asset_id`: the underlying asset denoting the market whose lend tokens are to be
             * enabled as collateral.
             **/
            depositAllCollateral: AugmentedSubmittable<(assetId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId]>;
            /**
             * Force updates a stored market. Returns `Err` if the market currency
             * does not exist.
             *
             * - `asset_id`: market related currency
             * - `market`: Configuration of the new lending market
             **/
            forceUpdateMarket: AugmentedSubmittable<(assetId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, market: LoansMarket | {
                collateralFactor?: any;
                liquidationThreshold?: any;
                reserveFactor?: any;
                closeFactor?: any;
                liquidateIncentive?: any;
                liquidateIncentiveReservedFactor?: any;
                rateModel?: any;
                state?: any;
                supplyCap?: any;
                borrowCap?: any;
                lendTokenId?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, LoansMarket]>;
            /**
             * The caller liquidates the borrower's collateral. This extrinsic may need to be called multiple
             * times to completely clear the borrower's bad debt, because of the `close_factor` parameter in
             * the market. See the `close_factor_may_require_multiple_liquidations_to_clear_bad_debt` unit
             * test for an example of this.
             *
             * - `borrower`: the borrower to be liquidated.
             * - `liquidation_asset_id`: the underlying asset to be liquidated.
             * - `repay_amount`: the amount of `liquidation_asset_id` to be repaid. This parameter can only
             * be as large as the `close_factor` market parameter allows
             * (`close_factor * borrower_debt_in_liquidation_asset`).
             * - `collateral_asset_id`: The underlying currency whose lend tokens to seize from the borrower.
             * Note that the liquidator has to redeem the received lend tokens from the market to convert them
             * to `collateral_asset_id`.
             **/
            liquidateBorrow: AugmentedSubmittable<(borrower: AccountId32 | string | Uint8Array, liquidationAssetId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, repayAmount: Compact<u128> | AnyNumber | Uint8Array, collateralAssetId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, InterbtcPrimitivesCurrencyId, Compact<u128>, InterbtcPrimitivesCurrencyId]>;
            /**
             * The caller supplies (lends) assets into the market and receives a corresponding amount
             * of lend tokens, at the current internal exchange rate.
             *
             * - `asset_id`: the asset to be deposited.
             * - `mint_amount`: the amount to be deposited.
             **/
            mint: AugmentedSubmittable<(assetId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, mintAmount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, Compact<u128>]>;
            /**
             * The caller redeems lend tokens for the underlying asset, at the current
             * internal exchange rate.
             *
             * - `asset_id`: the asset to be redeemed
             * - `redeem_amount`: the amount to be redeemed, expressed in the underyling currency (`asset_id`)
             **/
            redeem: AugmentedSubmittable<(assetId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, redeemAmount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, Compact<u128>]>;
            /**
             * The caller redeems their entire lend token balance in exchange for the underlying asset.
             * Note: this will fail if the account needs some of the collateral for backing open borrows,
             * or if any of the lend tokens are used by other pallets (e.g. used as vault collateral)
             *
             * - `asset_id`: the asset to be redeemed.
             **/
            redeemAll: AugmentedSubmittable<(assetId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId]>;
            /**
             * Sender redeems some of internal supplies in exchange for the underlying asset.
             *
             * - `asset_id`: the asset to be redeemed.
             * - `redeem_amount`: the amount to be redeemed.
             **/
            reduceIncentiveReserves: AugmentedSubmittable<(receiver: AccountId32 | string | Uint8Array, assetId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, redeemAmount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, InterbtcPrimitivesCurrencyId, Compact<u128>]>;
            /**
             * Reduces reserves (treasury's share of accrued interest) by transferring to receiver.
             *
             * May only be called from `T::ReserveOrigin`.
             *
             * - `receiver`: the receiver account.
             * - `asset_id`: the assets to be reduced.
             * - `reduce_amount`: the amount to be reduced.
             **/
            reduceReserves: AugmentedSubmittable<(receiver: AccountId32 | string | Uint8Array, assetId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, reduceAmount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, InterbtcPrimitivesCurrencyId, Compact<u128>]>;
            /**
             * The caller repays some of their debts.
             *
             * - `asset_id`: the asset to be repaid.
             * - `repay_amount`: the amount to be repaid, in the underlying currency (`asset_id`).
             **/
            repayBorrow: AugmentedSubmittable<(assetId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, repayAmount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, Compact<u128>]>;
            /**
             * The caller repays all of their debts.
             *
             * - `asset_id`: the asset to be repaid.
             **/
            repayBorrowAll: AugmentedSubmittable<(assetId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId]>;
            /**
             * Updates a stored market. Returns `Err` if the market currency does not exist.
             *
             * - `asset_id`: market related currency
             * - `collateral_factor`: the collateral utilization ratio
             * - `liquidation_threshold`: The collateral ratio when a borrower can be liquidated
             * - `reserve_factor`: fraction of interest set aside for reserves
             * - `close_factor`: max percentage of debt that can be liquidated in a single transaction
             * - `liquidate_incentive_reserved_factor`: liquidation share set aside for reserves
             * - `liquidate_incentive`: liquidation incentive ratio
             * - `supply_cap`: Upper bound of supplying
             * - `borrow_cap`: Upper bound of borrowing
             **/
            updateMarket: AugmentedSubmittable<(assetId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, collateralFactor: Option<Permill> | null | Uint8Array | Permill | AnyNumber, liquidationThreshold: Option<Permill> | null | Uint8Array | Permill | AnyNumber, reserveFactor: Option<Permill> | null | Uint8Array | Permill | AnyNumber, closeFactor: Option<Permill> | null | Uint8Array | Permill | AnyNumber, liquidateIncentiveReservedFactor: Option<Permill> | null | Uint8Array | Permill | AnyNumber, liquidateIncentive: Option<u128> | null | Uint8Array | u128 | AnyNumber, supplyCap: Option<u128> | null | Uint8Array | u128 | AnyNumber, borrowCap: Option<u128> | null | Uint8Array | u128 | AnyNumber) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, Option<Permill>, Option<Permill>, Option<Permill>, Option<Permill>, Option<Permill>, Option<u128>, Option<u128>, Option<u128>]>;
            /**
             * Updates reward speed for the specified market
             *
             * The origin must conform to `UpdateOrigin`.
             *
             * - `asset_id`: Market related currency
             * - `supply_reward_per_block`: supply reward amount per block.
             * - `borrow_reward_per_block`: borrow reward amount per block.
             **/
            updateMarketRewardSpeed: AugmentedSubmittable<(assetId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, supplyRewardPerBlock: Option<u128> | null | Uint8Array | u128 | AnyNumber, borrowRewardPerBlock: Option<u128> | null | Uint8Array | u128 | AnyNumber) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, Option<u128>, Option<u128>]>;
            /**
             * Updates the rate model of a stored market. Returns `Err` if the market
             * currency does not exist or the rate model is invalid.
             *
             * - `asset_id`: Market currency
             * - `rate_model`: The new rate model to set
             **/
            updateRateModel: AugmentedSubmittable<(assetId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, rateModel: LoansRateModelInterestRateModel | {
                Jump: any;
            } | {
                Curve: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, LoansRateModelInterestRateModel]>;
            /**
             * Caller disables their lend token balance as borrow collateral. This operation unlocks
             * the lend tokens, so they become transferrable.
             * This operation can only succeed if the caller's debt is backed by sufficient collateral
             * excluding this currency.
             *
             * - `asset_id`: the underlying asset denoting the market whose lend tokens are to be
             * disabled as collateral.
             **/
            withdrawAllCollateral: AugmentedSubmittable<(assetId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        multisig: {
            /**
             * Register approval for a dispatch to be made from a deterministic composite account if
             * approved by a total of `threshold - 1` of `other_signatories`.
             *
             * Payment: `DepositBase` will be reserved if this is the first approval, plus
             * `threshold` times `DepositFactor`. It is returned once this dispatch happens or
             * is cancelled.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * - `threshold`: The total number of approvals for this dispatch before it is executed.
             * - `other_signatories`: The accounts (other than the sender) who can approve this
             * dispatch. May not be empty.
             * - `maybe_timepoint`: If this is the first approval, then this must be `None`. If it is
             * not the first approval, then it must be `Some`, with the timepoint (block number and
             * transaction index) of the first approval transaction.
             * - `call_hash`: The hash of the call to be executed.
             *
             * NOTE: If this is the final approval, you will want to use `as_multi` instead.
             *
             * ## Complexity
             * - `O(S)`.
             * - Up to one balance-reserve or unreserve operation.
             * - One passthrough operation, one insert, both `O(S)` where `S` is the number of
             * signatories. `S` is capped by `MaxSignatories`, with weight being proportional.
             * - One encode & hash, both of complexity `O(S)`.
             * - Up to one binary search and insert (`O(logS + S)`).
             * - I/O: 1 read `O(S)`, up to 1 mutate `O(S)`. Up to one remove.
             * - One event.
             * - Storage: inserts one item, value size bounded by `MaxSignatories`, with a deposit
             * taken for its lifetime of `DepositBase + threshold * DepositFactor`.
             **/
            approveAsMulti: AugmentedSubmittable<(threshold: u16 | AnyNumber | Uint8Array, otherSignatories: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[], maybeTimepoint: Option<PalletMultisigTimepoint> | null | Uint8Array | PalletMultisigTimepoint | {
                height?: any;
                index?: any;
            } | string, callHash: U8aFixed | string | Uint8Array, maxWeight: SpWeightsWeightV2Weight | {
                refTime?: any;
                proofSize?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u16, Vec<AccountId32>, Option<PalletMultisigTimepoint>, U8aFixed, SpWeightsWeightV2Weight]>;
            /**
             * Register approval for a dispatch to be made from a deterministic composite account if
             * approved by a total of `threshold - 1` of `other_signatories`.
             *
             * If there are enough, then dispatch the call.
             *
             * Payment: `DepositBase` will be reserved if this is the first approval, plus
             * `threshold` times `DepositFactor`. It is returned once this dispatch happens or
             * is cancelled.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * - `threshold`: The total number of approvals for this dispatch before it is executed.
             * - `other_signatories`: The accounts (other than the sender) who can approve this
             * dispatch. May not be empty.
             * - `maybe_timepoint`: If this is the first approval, then this must be `None`. If it is
             * not the first approval, then it must be `Some`, with the timepoint (block number and
             * transaction index) of the first approval transaction.
             * - `call`: The call to be executed.
             *
             * NOTE: Unless this is the final approval, you will generally want to use
             * `approve_as_multi` instead, since it only requires a hash of the call.
             *
             * Result is equivalent to the dispatched result if `threshold` is exactly `1`. Otherwise
             * on success, result is `Ok` and the result from the interior call, if it was executed,
             * may be found in the deposited `MultisigExecuted` event.
             *
             * ## Complexity
             * - `O(S + Z + Call)`.
             * - Up to one balance-reserve or unreserve operation.
             * - One passthrough operation, one insert, both `O(S)` where `S` is the number of
             * signatories. `S` is capped by `MaxSignatories`, with weight being proportional.
             * - One call encode & hash, both of complexity `O(Z)` where `Z` is tx-len.
             * - One encode & hash, both of complexity `O(S)`.
             * - Up to one binary search and insert (`O(logS + S)`).
             * - I/O: 1 read `O(S)`, up to 1 mutate `O(S)`. Up to one remove.
             * - One event.
             * - The weight of the `call`.
             * - Storage: inserts one item, value size bounded by `MaxSignatories`, with a deposit
             * taken for its lifetime of `DepositBase + threshold * DepositFactor`.
             **/
            asMulti: AugmentedSubmittable<(threshold: u16 | AnyNumber | Uint8Array, otherSignatories: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[], maybeTimepoint: Option<PalletMultisigTimepoint> | null | Uint8Array | PalletMultisigTimepoint | {
                height?: any;
                index?: any;
            } | string, call: Call | IMethod | string | Uint8Array, maxWeight: SpWeightsWeightV2Weight | {
                refTime?: any;
                proofSize?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u16, Vec<AccountId32>, Option<PalletMultisigTimepoint>, Call, SpWeightsWeightV2Weight]>;
            /**
             * Immediately dispatch a multi-signature call using a single approval from the caller.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * - `other_signatories`: The accounts (other than the sender) who are part of the
             * multi-signature, but do not participate in the approval process.
             * - `call`: The call to be executed.
             *
             * Result is equivalent to the dispatched result.
             *
             * ## Complexity
             * O(Z + C) where Z is the length of the call and C its execution weight.
             **/
            asMultiThreshold1: AugmentedSubmittable<(otherSignatories: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[], call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>, Call]>;
            /**
             * Cancel a pre-existing, on-going multisig transaction. Any deposit reserved previously
             * for this operation will be unreserved on success.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * - `threshold`: The total number of approvals for this dispatch before it is executed.
             * - `other_signatories`: The accounts (other than the sender) who can approve this
             * dispatch. May not be empty.
             * - `timepoint`: The timepoint (block number and transaction index) of the first approval
             * transaction for this dispatch.
             * - `call_hash`: The hash of the call to be executed.
             *
             * ## Complexity
             * - `O(S)`.
             * - Up to one balance-reserve or unreserve operation.
             * - One passthrough operation, one insert, both `O(S)` where `S` is the number of
             * signatories. `S` is capped by `MaxSignatories`, with weight being proportional.
             * - One encode & hash, both of complexity `O(S)`.
             * - One event.
             * - I/O: 1 read `O(S)`, one remove.
             * - Storage: removes one item.
             **/
            cancelAsMulti: AugmentedSubmittable<(threshold: u16 | AnyNumber | Uint8Array, otherSignatories: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[], timepoint: PalletMultisigTimepoint | {
                height?: any;
                index?: any;
            } | string | Uint8Array, callHash: U8aFixed | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u16, Vec<AccountId32>, PalletMultisigTimepoint, U8aFixed]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        multiTransactionPayment: {
            withFeeSwapPath: AugmentedSubmittable<(path: Vec<InterbtcPrimitivesCurrencyId> | (InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array)[], amountInMax: u128 | AnyNumber | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<InterbtcPrimitivesCurrencyId>, u128, Call]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        nomination: {
            depositCollateral: AugmentedSubmittable<(vaultId: InterbtcPrimitivesVaultId | {
                accountId?: any;
                currencies?: any;
            } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesVaultId, u128]>;
            /**
             * Allow nomination for this vault
             **/
            optInToNomination: AugmentedSubmittable<(currencyPair: InterbtcPrimitivesVaultCurrencyPair | {
                collateral?: any;
                wrapped?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesVaultCurrencyPair]>;
            /**
             * Disallow nomination for this vault
             **/
            optOutOfNomination: AugmentedSubmittable<(currencyPair: InterbtcPrimitivesVaultCurrencyPair | {
                collateral?: any;
                wrapped?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesVaultCurrencyPair]>;
            setNominationEnabled: AugmentedSubmittable<(enabled: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [bool]>;
            setNominationLimit: AugmentedSubmittable<(currencyPair: InterbtcPrimitivesVaultCurrencyPair | {
                collateral?: any;
                wrapped?: any;
            } | string | Uint8Array, limit: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesVaultCurrencyPair, u128]>;
            withdrawCollateral: AugmentedSubmittable<(vaultId: InterbtcPrimitivesVaultId | {
                accountId?: any;
                currencies?: any;
            } | string | Uint8Array, amount: Option<u128> | null | Uint8Array | u128 | AnyNumber, index: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesVaultId, Option<u128>, Option<u32>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        oracle: {
            /**
             * Feeds data from the oracles, e.g., the exchange rates. This function
             * is intended to be API-compatible with orml-oracle.
             *
             * # Arguments
             *
             * * `values` - a vector of (key, value) pairs to submit
             **/
            feedValues: AugmentedSubmittable<(values: Vec<ITuple<[InterbtcPrimitivesOracleKey, u128]>> | ([InterbtcPrimitivesOracleKey | {
                ExchangeRate: any;
            } | {
                FeeEstimation: any;
            } | string | Uint8Array, u128 | AnyNumber | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[InterbtcPrimitivesOracleKey, u128]>>]>;
            /**
             * Adds an authorized oracle account (only executable by the Root account)
             *
             * # Arguments
             * * `account_id` - the account Id of the oracle
             * * `name` - a descriptive name for the oracle
             **/
            insertAuthorizedOracle: AugmentedSubmittable<(accountId: AccountId32 | string | Uint8Array, name: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, Bytes]>;
            /**
             * Removes an authorized oracle account (only executable by the Root account)
             *
             * # Arguments
             * * `account_id` - the account Id of the oracle
             **/
            removeAuthorizedOracle: AugmentedSubmittable<(accountId: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        parachainSystem: {
            /**
             * Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be supplied
             * later.
             *
             * The `check_version` parameter sets a boolean flag for whether or not the runtime's spec
             * version and name should be verified on upgrade. Since the authorization only has a hash,
             * it cannot actually perform the verification.
             *
             * This call requires Root origin.
             **/
            authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array, checkVersion: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, bool]>;
            /**
             * Provide the preimage (runtime binary) `code` for an upgrade that has been authorized.
             *
             * If the authorization required a version check, this call will ensure the spec name
             * remains unchanged and that the spec version has increased.
             *
             * Note that this function will not apply the new `code`, but only attempt to schedule the
             * upgrade with the Relay Chain.
             *
             * All origins are allowed.
             **/
            enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
            /**
             * Set the current validation data.
             *
             * This should be invoked exactly once per block. It will panic at the finalization
             * phase if the call was not invoked.
             *
             * The dispatch origin for this call must be `Inherent`
             *
             * As a side effect, this function upgrades the current validation function
             * if the appropriate time has come.
             **/
            setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | {
                validationData?: any;
                relayChainState?: any;
                downwardMessages?: any;
                horizontalMessages?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;
            sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        polkadotXcm: {
            /**
             * Execute an XCM message from a local, signed, origin.
             *
             * An event is deposited indicating whether `msg` could be executed completely or only
             * partially.
             *
             * No more than `max_weight` will be used in its attempted execution. If this is less than the
             * maximum amount of weight that the message could take to be executed, then no execution
             * attempt will be made.
             *
             * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully
             * to completion; only that *some* of it was executed.
             **/
            execute: AugmentedSubmittable<(message: XcmVersionedXcm | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array, maxWeight: SpWeightsWeightV2Weight | {
                refTime?: any;
                proofSize?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, SpWeightsWeightV2Weight]>;
            /**
             * Set a safe XCM version (the version that XCM should be encoded with if the most recent
             * version a destination can accept is unknown).
             *
             * - `origin`: Must be an origin specified by AdminOrigin.
             * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.
             **/
            forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;
            /**
             * Ask a location to notify us regarding their XCM version and any changes to it.
             *
             * - `origin`: Must be an origin specified by AdminOrigin.
             * - `location`: The location to which we should subscribe for XCM version notifications.
             **/
            forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;
            /**
             * Set or unset the global suspension state of the XCM executor.
             *
             * - `origin`: Must be an origin specified by AdminOrigin.
             * - `suspended`: `true` to suspend, `false` to resume.
             **/
            forceSuspension: AugmentedSubmittable<(suspended: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [bool]>;
            /**
             * Require that a particular destination should no longer notify us regarding any XCM
             * version changes.
             *
             * - `origin`: Must be an origin specified by AdminOrigin.
             * - `location`: The location to which we are currently subscribed for XCM version
             * notifications which we no longer desire.
             **/
            forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;
            /**
             * Extoll that a particular destination can be communicated with through a particular
             * version of XCM.
             *
             * - `origin`: Must be an origin specified by AdminOrigin.
             * - `location`: The destination that is being described.
             * - `xcm_version`: The latest version of XCM that `location` supports.
             **/
            forceXcmVersion: AugmentedSubmittable<(location: XcmV3MultiLocation | {
                parents?: any;
                interior?: any;
            } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV3MultiLocation, u32]>;
            /**
             * Transfer some assets from the local chain to the sovereign account of a destination
             * chain and forward a notification XCM.
             *
             * Fee payment on the destination side is made from the asset in the `assets` vector of
             * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight
             * is needed than `weight_limit`, then the operation will fail and the assets send may be
             * at risk.
             *
             * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.
             * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send
             * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.
             * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be
             * an `AccountId32` value.
             * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the
             * `dest` side.
             * - `fee_asset_item`: The index into `assets` of the item which should be used to pay
             * fees.
             * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.
             **/
            limitedReserveTransferAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array, assets: XcmVersionedMultiAssets | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array, weightLimit: XcmV3WeightLimit | {
                Unlimited: any;
            } | {
                Limited: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32, XcmV3WeightLimit]>;
            /**
             * Teleport some assets from the local chain to some destination chain.
             *
             * Fee payment on the destination side is made from the asset in the `assets` vector of
             * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight
             * is needed than `weight_limit`, then the operation will fail and the assets send may be
             * at risk.
             *
             * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.
             * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send
             * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.
             * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be
             * an `AccountId32` value.
             * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the
             * `dest` side. May not be empty.
             * - `fee_asset_item`: The index into `assets` of the item which should be used to pay
             * fees.
             * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.
             **/
            limitedTeleportAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array, assets: XcmVersionedMultiAssets | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array, weightLimit: XcmV3WeightLimit | {
                Unlimited: any;
            } | {
                Limited: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32, XcmV3WeightLimit]>;
            /**
             * Transfer some assets from the local chain to the sovereign account of a destination
             * chain and forward a notification XCM.
             *
             * Fee payment on the destination side is made from the asset in the `assets` vector of
             * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,
             * with all fees taken as needed from the asset.
             *
             * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.
             * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send
             * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.
             * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be
             * an `AccountId32` value.
             * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the
             * `dest` side.
             * - `fee_asset_item`: The index into `assets` of the item which should be used to pay
             * fees.
             **/
            reserveTransferAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array, assets: XcmVersionedMultiAssets | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32]>;
            send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array, message: XcmVersionedXcm | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;
            /**
             * Teleport some assets from the local chain to some destination chain.
             *
             * Fee payment on the destination side is made from the asset in the `assets` vector of
             * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,
             * with all fees taken as needed from the asset.
             *
             * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.
             * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send
             * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.
             * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be
             * an `AccountId32` value.
             * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the
             * `dest` side. May not be empty.
             * - `fee_asset_item`: The index into `assets` of the item which should be used to pay
             * fees.
             **/
            teleportAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array, assets: XcmVersionedMultiAssets | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        preimage: {
            /**
             * Register a preimage on-chain.
             *
             * If the preimage was previously requested, no fees or deposits are taken for providing
             * the preimage. Otherwise, a deposit is taken proportional to the size of the preimage.
             **/
            notePreimage: AugmentedSubmittable<(bytes: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
            /**
             * Request a preimage be uploaded to the chain without paying any fees or deposits.
             *
             * If the preimage requests has already been provided on-chain, we unreserve any deposit
             * a user may have paid, and take the control of the preimage out of their hands.
             **/
            requestPreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;
            /**
             * Clear an unrequested preimage from the runtime storage.
             *
             * If `len` is provided, then it will be a much cheaper operation.
             *
             * - `hash`: The hash of the preimage to be removed from the store.
             * - `len`: The length of the preimage of `hash`.
             **/
            unnotePreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;
            /**
             * Clear a previously made request for a preimage.
             *
             * NOTE: THIS MUST NOT BE CALLED ON `hash` MORE TIMES THAN `request_preimage`.
             **/
            unrequestPreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        proxy: {
            /**
             * Register a proxy account for the sender that is able to make calls on its behalf.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * Parameters:
             * - `proxy`: The account that the `caller` would like to make a proxy.
             * - `proxy_type`: The permissions allowed for this proxy account.
             * - `delay`: The announcement period required of the initial proxy. Will generally be
             * zero.
             **/
            addProxy: AugmentedSubmittable<(delegate: AccountId32 | string | Uint8Array, proxyType: InterlayRuntimeParachainProxyType | 'Any' | number | Uint8Array, delay: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, InterlayRuntimeParachainProxyType, u32]>;
            /**
             * Publish the hash of a proxy-call that will be made in the future.
             *
             * This must be called some number of blocks before the corresponding `proxy` is attempted
             * if the delay associated with the proxy relationship is greater than zero.
             *
             * No more than `MaxPending` announcements may be made at any one time.
             *
             * This will take a deposit of `AnnouncementDepositFactor` as well as
             * `AnnouncementDepositBase` if there are no other pending announcements.
             *
             * The dispatch origin for this call must be _Signed_ and a proxy of `real`.
             *
             * Parameters:
             * - `real`: The account that the proxy will make a call on behalf of.
             * - `call_hash`: The hash of the call to be made by the `real` account.
             **/
            announce: AugmentedSubmittable<(real: AccountId32 | string | Uint8Array, callHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, H256]>;
            /**
             * Spawn a fresh new account that is guaranteed to be otherwise inaccessible, and
             * initialize it with a proxy of `proxy_type` for `origin` sender.
             *
             * Requires a `Signed` origin.
             *
             * - `proxy_type`: The type of the proxy that the sender will be registered as over the
             * new account. This will almost always be the most permissive `ProxyType` possible to
             * allow for maximum flexibility.
             * - `index`: A disambiguation index, in case this is called multiple times in the same
             * transaction (e.g. with `utility::batch`). Unless you're using `batch` you probably just
             * want to use `0`.
             * - `delay`: The announcement period required of the initial proxy. Will generally be
             * zero.
             *
             * Fails with `Duplicate` if this has already been called in this transaction, from the
             * same sender, with the same parameters.
             *
             * Fails if there are insufficient funds to pay for deposit.
             **/
            createPure: AugmentedSubmittable<(proxyType: InterlayRuntimeParachainProxyType | 'Any' | number | Uint8Array, delay: u32 | AnyNumber | Uint8Array, index: u16 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterlayRuntimeParachainProxyType, u32, u16]>;
            /**
             * Removes a previously spawned pure proxy.
             *
             * WARNING: **All access to this account will be lost.** Any funds held in it will be
             * inaccessible.
             *
             * Requires a `Signed` origin, and the sender account must have been created by a call to
             * `pure` with corresponding parameters.
             *
             * - `spawner`: The account that originally called `pure` to create this account.
             * - `index`: The disambiguation index originally passed to `pure`. Probably `0`.
             * - `proxy_type`: The proxy type originally passed to `pure`.
             * - `height`: The height of the chain when the call to `pure` was processed.
             * - `ext_index`: The extrinsic index in which the call to `pure` was processed.
             *
             * Fails with `NoPermission` in case the caller is not a previously created pure
             * account whose `pure` call has corresponding parameters.
             **/
            killPure: AugmentedSubmittable<(spawner: AccountId32 | string | Uint8Array, proxyType: InterlayRuntimeParachainProxyType | 'Any' | number | Uint8Array, index: u16 | AnyNumber | Uint8Array, height: Compact<u32> | AnyNumber | Uint8Array, extIndex: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, InterlayRuntimeParachainProxyType, u16, Compact<u32>, Compact<u32>]>;
            /**
             * Dispatch the given `call` from an account that the sender is authorised for through
             * `add_proxy`.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * Parameters:
             * - `real`: The account that the proxy will make a call on behalf of.
             * - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call.
             * - `call`: The call to be made by the `real` account.
             **/
            proxy: AugmentedSubmittable<(real: AccountId32 | string | Uint8Array, forceProxyType: Option<InterlayRuntimeParachainProxyType> | null | Uint8Array | InterlayRuntimeParachainProxyType | 'Any' | number, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, Option<InterlayRuntimeParachainProxyType>, Call]>;
            /**
             * Dispatch the given `call` from an account that the sender is authorized for through
             * `add_proxy`.
             *
             * Removes any corresponding announcement(s).
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * Parameters:
             * - `real`: The account that the proxy will make a call on behalf of.
             * - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call.
             * - `call`: The call to be made by the `real` account.
             **/
            proxyAnnounced: AugmentedSubmittable<(delegate: AccountId32 | string | Uint8Array, real: AccountId32 | string | Uint8Array, forceProxyType: Option<InterlayRuntimeParachainProxyType> | null | Uint8Array | InterlayRuntimeParachainProxyType | 'Any' | number, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, AccountId32, Option<InterlayRuntimeParachainProxyType>, Call]>;
            /**
             * Remove the given announcement of a delegate.
             *
             * May be called by a target (proxied) account to remove a call that one of their delegates
             * (`delegate`) has announced they want to execute. The deposit is returned.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * Parameters:
             * - `delegate`: The account that previously announced the call.
             * - `call_hash`: The hash of the call to be made.
             **/
            rejectAnnouncement: AugmentedSubmittable<(delegate: AccountId32 | string | Uint8Array, callHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, H256]>;
            /**
             * Remove a given announcement.
             *
             * May be called by a proxy account to remove a call they previously announced and return
             * the deposit.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * Parameters:
             * - `real`: The account that the proxy will make a call on behalf of.
             * - `call_hash`: The hash of the call to be made by the `real` account.
             **/
            removeAnnouncement: AugmentedSubmittable<(real: AccountId32 | string | Uint8Array, callHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, H256]>;
            /**
             * Unregister all proxy accounts for the sender.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * WARNING: This may be called on accounts created by `pure`, however if done, then
             * the unreserved fees will be inaccessible. **All access to this account will be lost.**
             **/
            removeProxies: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Unregister a proxy account for the sender.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * Parameters:
             * - `proxy`: The account that the `caller` would like to remove as a proxy.
             * - `proxy_type`: The permissions currently enabled for the removed proxy account.
             **/
            removeProxy: AugmentedSubmittable<(delegate: AccountId32 | string | Uint8Array, proxyType: InterlayRuntimeParachainProxyType | 'Any' | number | Uint8Array, delay: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, InterlayRuntimeParachainProxyType, u32]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        redeem: {
            /**
             * If a redeem request is not completed on time, the redeem request can be cancelled.
             * The user that initially requested the redeem process calls this function to obtain
             * the Vault’s collateral as compensation for not transferring the BTC back to their address.
             *
             * # Arguments
             *
             * * `origin` - sender of the transaction
             * * `redeem_id` - identifier of redeem request as output from request_redeem
             * * `reimburse` - specifying if the user wishes to be reimbursed in collateral
             * and slash the Vault, or wishes to keep the tokens (and retry
             * Redeem with another Vault)
             **/
            cancelRedeem: AugmentedSubmittable<(redeemId: H256 | string | Uint8Array, reimburse: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, bool]>;
            /**
             * A Vault calls this function after receiving an RequestRedeem event with their public key.
             * Before calling the function, the Vault transfers the specific amount of BTC to the BTC address
             * given in the original redeem request. The Vault completes the redeem with this function.
             *
             * # Arguments
             *
             * * `origin` - anyone executing this redeem request
             * * `redeem_id` - identifier of redeem request as output from request_redeem
             * * `tx_id` - transaction hash
             * * `merkle_proof` - membership proof
             * * `transaction` - tx containing payment
             **/
            executeRedeem: AugmentedSubmittable<(redeemId: H256 | string | Uint8Array, uncheckedTransaction: BitcoinFullTransactionProof | {
                userTxProof?: any;
                coinbaseProof?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, BitcoinFullTransactionProof]>;
            /**
             * When a Vault is liquidated, its collateral is slashed up to 150% of the liquidated BTC value.
             * To re-establish the physical 1:1 peg, the bridge allows users to burn issued tokens in return for
             * collateral at a premium rate.
             *
             * # Arguments
             *
             * * `origin` - sender of the transaction
             * * `collateral_currency` - currency to be received
             * * `wrapped_currency` - currency of the wrapped token to burn
             * * `amount_wrapped` - amount of issued tokens to burn
             **/
            liquidationRedeem: AugmentedSubmittable<(currencies: InterbtcPrimitivesVaultCurrencyPair | {
                collateral?: any;
                wrapped?: any;
            } | string | Uint8Array, amountWrapped: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesVaultCurrencyPair, Compact<u128>]>;
            /**
             * Mint tokens for a redeem that was cancelled with reimburse=true. This is
             * only possible if at the time of the cancel_redeem, the vault did not have
             * sufficient collateral after being slashed to back the tokens that the user
             * used to hold.
             *
             * # Arguments
             *
             * * `origin` - the dispatch origin of this call (must be _Root_)
             * * `redeem_id` - identifier of redeem request as output from request_redeem
             *
             * # Weight: `O(1)`
             **/
            mintTokensForReimbursedRedeem: AugmentedSubmittable<(currencyPair: InterbtcPrimitivesVaultCurrencyPair | {
                collateral?: any;
                wrapped?: any;
            } | string | Uint8Array, redeemId: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesVaultCurrencyPair, H256]>;
            /**
             * Initializes a request to burn issued tokens against a Vault with sufficient tokens. It will
             * also ensure that the Parachain status is RUNNING.
             *
             * # Arguments
             *
             * * `origin` - sender of the transaction
             * * `amount` - amount of issued tokens
             * * `btc_address` - the address to receive BTC
             * * `vault_id` - address of the vault
             **/
            requestRedeem: AugmentedSubmittable<(amountWrapped: Compact<u128> | AnyNumber | Uint8Array, btcAddress: BitcoinAddress | {
                P2PKH: any;
            } | {
                P2SH: any;
            } | {
                P2WPKHv0: any;
            } | {
                P2WSHv0: any;
            } | string | Uint8Array, vaultId: InterbtcPrimitivesVaultId | {
                accountId?: any;
                currencies?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u128>, BitcoinAddress, InterbtcPrimitivesVaultId]>;
            selfRedeem: AugmentedSubmittable<(currencyPair: InterbtcPrimitivesVaultCurrencyPair | {
                collateral?: any;
                wrapped?: any;
            } | string | Uint8Array, amountWrapped: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesVaultCurrencyPair, u128]>;
            /**
             * Set the default redeem period for tx verification.
             *
             * # Arguments
             *
             * * `origin` - the dispatch origin of this call (must be _Root_)
             * * `period` - default period for new requests
             *
             * # Weight: `O(1)`
             **/
            setRedeemPeriod: AugmentedSubmittable<(period: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        replace: {
            /**
             * Accept request of vault replacement
             *
             * # Arguments
             *
             * * `origin` - the initiator of the transaction: the new vault
             * * `old_vault` - id of the old vault that we are (possibly partially) replacing
             * * `collateral` - the collateral for replacement
             * * `btc_address` - the address that old-vault should transfer the btc to
             **/
            acceptReplace: AugmentedSubmittable<(currencyPair: InterbtcPrimitivesVaultCurrencyPair | {
                collateral?: any;
                wrapped?: any;
            } | string | Uint8Array, oldVault: InterbtcPrimitivesVaultId | {
                accountId?: any;
                currencies?: any;
            } | string | Uint8Array, amountBtc: Compact<u128> | AnyNumber | Uint8Array, collateral: Compact<u128> | AnyNumber | Uint8Array, btcAddress: BitcoinAddress | {
                P2PKH: any;
            } | {
                P2SH: any;
            } | {
                P2WPKHv0: any;
            } | {
                P2WSHv0: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesVaultCurrencyPair, InterbtcPrimitivesVaultId, Compact<u128>, Compact<u128>, BitcoinAddress]>;
            /**
             * Cancel vault replacement
             *
             * # Arguments
             *
             * * `origin` - sender of the transaction: anyone
             * * `replace_id` - the ID of the replacement request
             **/
            cancelReplace: AugmentedSubmittable<(replaceId: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;
            /**
             * Execute vault replacement
             *
             * # Arguments
             *
             * * `origin` - sender of the transaction: the new vault
             * * `replace_id` - the ID of the replacement request
             * * 'merkle_proof' - the merkle root of the block
             * * `raw_tx` - the transaction id in bytes
             **/
            executeReplace: AugmentedSubmittable<(replaceId: H256 | string | Uint8Array, uncheckedTransaction: BitcoinFullTransactionProof | {
                userTxProof?: any;
                coinbaseProof?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, BitcoinFullTransactionProof]>;
            /**
             * Request the replacement of a new vault ownership
             *
             * # Arguments
             *
             * * `origin` - sender of the transaction
             * * `amount` - amount of issued tokens
             * * `griefing_collateral` - amount of collateral
             **/
            requestReplace: AugmentedSubmittable<(currencyPair: InterbtcPrimitivesVaultCurrencyPair | {
                collateral?: any;
                wrapped?: any;
            } | string | Uint8Array, amount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesVaultCurrencyPair, Compact<u128>]>;
            /**
             * Set the default replace period for tx verification.
             *
             * # Arguments
             *
             * * `origin` - the dispatch origin of this call (must be _Root_)
             * * `period` - default period for new requests
             *
             * # Weight: `O(1)`
             **/
            setReplacePeriod: AugmentedSubmittable<(period: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
            /**
             * Withdraw a request of vault replacement
             *
             * # Arguments
             *
             * * `origin` - sender of the transaction: the old vault
             **/
            withdrawReplace: AugmentedSubmittable<(currencyPair: InterbtcPrimitivesVaultCurrencyPair | {
                collateral?: any;
                wrapped?: any;
            } | string | Uint8Array, amount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesVaultCurrencyPair, Compact<u128>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        scheduler: {
            /**
             * Cancel an anonymously scheduled task.
             **/
            cancel: AugmentedSubmittable<(when: u32 | AnyNumber | Uint8Array, index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;
            /**
             * Cancel a named scheduled task.
             **/
            cancelNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed]>;
            /**
             * Anonymously schedule a task.
             **/
            schedule: AugmentedSubmittable<(when: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, Option<ITuple<[u32, u32]>>, u8, Call]>;
            /**
             * Anonymously schedule a task after a delay.
             **/
            scheduleAfter: AugmentedSubmittable<(after: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, Option<ITuple<[u32, u32]>>, u8, Call]>;
            /**
             * Schedule a named task.
             **/
            scheduleNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, when: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u32, Option<ITuple<[u32, u32]>>, u8, Call]>;
            /**
             * Schedule a named task after a delay.
             **/
            scheduleNamedAfter: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, after: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u32, Option<ITuple<[u32, u32]>>, u8, Call]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        security: {
            /**
             * Activate or deactivate active block counting.
             **/
            activateCounter: AugmentedSubmittable<(isActive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [bool]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        session: {
            /**
             * Removes any session key(s) of the function caller.
             *
             * This doesn't take effect until the next session.
             *
             * The dispatch origin of this function must be Signed and the account must be either be
             * convertible to a validator ID using the chain's typical addressing system (this usually
             * means being a controller account) or directly convertible into a validator ID (which
             * usually means being a stash account).
             *
             * ## Complexity
             * - `O(1)` in number of key types. Actual cost depends on the number of length of
             * `T::Keys::key_ids()` which is fixed.
             **/
            purgeKeys: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Sets the session key(s) of the function caller to `keys`.
             * Allows an account to set its session key prior to becoming a validator.
             * This doesn't take effect until the next session.
             *
             * The dispatch origin of this function must be signed.
             *
             * ## Complexity
             * - `O(1)`. Actual cost depends on the number of length of `T::Keys::key_ids()` which is
             * fixed.
             **/
            setKeys: AugmentedSubmittable<(keys: InterlayRuntimeParachainSessionKeys | {
                aura?: any;
            } | string | Uint8Array, proof: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterlayRuntimeParachainSessionKeys, Bytes]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        sudo: {
            /**
             * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo
             * key.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * ## Complexity
             * - O(1).
             **/
            setKey: AugmentedSubmittable<(updated: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;
            /**
             * Authenticates the sudo key and dispatches a function call with `Root` origin.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * ## Complexity
             * - O(1).
             **/
            sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;
            /**
             * Authenticates the sudo key and dispatches a function call with `Signed` origin from
             * a given account.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * ## Complexity
             * - O(1).
             **/
            sudoAs: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, Call]>;
            /**
             * Authenticates the sudo key and dispatches a function call with `Root` origin.
             * This function does not check the weight of the call, and instead allows the
             * Sudo user to specify the weight of the call.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * ## Complexity
             * - O(1).
             **/
            sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: SpWeightsWeightV2Weight | {
                refTime?: any;
                proofSize?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, SpWeightsWeightV2Weight]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        supply: {
            setStartHeightAndInflation: AugmentedSubmittable<(startHeight: u32 | AnyNumber | Uint8Array, inflation: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u128]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        system: {
            /**
             * Kill all storage items with a key that starts with the given prefix.
             *
             * **NOTE:** We rely on the Root origin to provide us the number of subkeys under
             * the prefix we are removing to accurately calculate the weight of this function.
             **/
            killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;
            /**
             * Kill some items from storage.
             **/
            killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;
            /**
             * Make some on-chain remark.
             *
             * ## Complexity
             * - `O(1)`
             **/
            remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
            /**
             * Make some on-chain remark and emit event.
             **/
            remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
            /**
             * Set the new runtime code.
             *
             * ## Complexity
             * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`
             **/
            setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
            /**
             * Set the new runtime code without doing any checks of the given `code`.
             *
             * ## Complexity
             * - `O(C)` where `C` length of `code`
             **/
            setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
            /**
             * Set the number of pages in the WebAssembly environment's heap.
             **/
            setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;
            /**
             * Set some items of storage.
             **/
            setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        technicalCommittee: {
            /**
             * Close a vote that is either approved, disapproved or whose voting period has ended.
             *
             * May be called by any signed account in order to finish voting and close the proposal.
             *
             * If called before the end of the voting period it will only close the vote if it is
             * has enough votes to be approved or disapproved.
             *
             * If called after the end of the voting period abstentions are counted as rejections
             * unless there is a prime member set and the prime member cast an approval.
             *
             * If the close operation completes successfully with disapproval, the transaction fee will
             * be waived. Otherwise execution of the approved operation will be charged to the caller.
             *
             * + `proposal_weight_bound`: The maximum amount of weight consumed by executing the closed
             * proposal.
             * + `length_bound`: The upper bound for the length of the proposal in storage. Checked via
             * `storage::read` so it is `size_of::<u32>() == 4` larger than the pure length.
             *
             * ## Complexity
             * - `O(B + M + P1 + P2)` where:
             * - `B` is `proposal` size in bytes (length-fee-bounded)
             * - `M` is members-count (code- and governance-bounded)
             * - `P1` is the complexity of `proposal` preimage.
             * - `P2` is proposal-count (code-bounded)
             **/
            close: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array, index: Compact<u32> | AnyNumber | Uint8Array, proposalWeightBound: SpWeightsWeightV2Weight | {
                refTime?: any;
                proofSize?: any;
            } | string | Uint8Array, lengthBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, Compact<u32>, SpWeightsWeightV2Weight, Compact<u32>]>;
            /**
             * Disapprove a proposal, close, and remove it from the system, regardless of its current
             * state.
             *
             * Must be called by the Root origin.
             *
             * Parameters:
             * * `proposal_hash`: The hash of the proposal that should be disapproved.
             *
             * ## Complexity
             * O(P) where P is the number of max proposals
             **/
            disapproveProposal: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;
            /**
             * Dispatch a proposal from a member using the `Member` origin.
             *
             * Origin must be a member of the collective.
             *
             * ## Complexity:
             * - `O(B + M + P)` where:
             * - `B` is `proposal` size in bytes (length-fee-bounded)
             * - `M` members-count (code-bounded)
             * - `P` complexity of dispatching `proposal`
             **/
            execute: AugmentedSubmittable<(proposal: Call | IMethod | string | Uint8Array, lengthBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, Compact<u32>]>;
            /**
             * Add a new proposal to either be voted on or executed directly.
             *
             * Requires the sender to be member.
             *
             * `threshold` determines whether `proposal` is executed directly (`threshold < 2`)
             * or put up for voting.
             *
             * ## Complexity
             * - `O(B + M + P1)` or `O(B + M + P2)` where:
             * - `B` is `proposal` size in bytes (length-fee-bounded)
             * - `M` is members-count (code- and governance-bounded)
             * - branching is influenced by `threshold` where:
             * - `P1` is proposal execution complexity (`threshold < 2`)
             * - `P2` is proposals-count (code-bounded) (`threshold >= 2`)
             **/
            propose: AugmentedSubmittable<(threshold: Compact<u32> | AnyNumber | Uint8Array, proposal: Call | IMethod | string | Uint8Array, lengthBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Call, Compact<u32>]>;
            /**
             * Set the collective's membership.
             *
             * - `new_members`: The new member list. Be nice to the chain and provide it sorted.
             * - `prime`: The prime member whose vote sets the default.
             * - `old_count`: The upper bound for the previous number of members in storage. Used for
             * weight estimation.
             *
             * The dispatch of this call must be `SetMembersOrigin`.
             *
             * NOTE: Does not enforce the expected `MaxMembers` limit on the amount of members, but
             * the weight estimations rely on it to estimate dispatchable weight.
             *
             * # WARNING:
             *
             * The `pallet-collective` can also be managed by logic outside of the pallet through the
             * implementation of the trait [`ChangeMembers`].
             * Any call to `set_members` must be careful that the member set doesn't get out of sync
             * with other logic managing the member set.
             *
             * ## Complexity:
             * - `O(MP + N)` where:
             * - `M` old-members-count (code- and governance-bounded)
             * - `N` new-members-count (code- and governance-bounded)
             * - `P` proposals-count (code-bounded)
             **/
            setMembers: AugmentedSubmittable<(newMembers: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[], prime: Option<AccountId32> | null | Uint8Array | AccountId32 | string, oldCount: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>, Option<AccountId32>, u32]>;
            /**
             * Add an aye or nay vote for the sender to the given proposal.
             *
             * Requires the sender to be a member.
             *
             * Transaction fees will be waived if the member is voting on any particular proposal
             * for the first time and the call is successful. Subsequent vote changes will charge a
             * fee.
             * ## Complexity
             * - `O(M)` where `M` is members-count (code- and governance-bounded)
             **/
            vote: AugmentedSubmittable<(proposal: H256 | string | Uint8Array, index: Compact<u32> | AnyNumber | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, Compact<u32>, bool]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        technicalMembership: {
            /**
             * Add a member `who` to the set.
             *
             * May only be called from `T::AddOrigin`.
             **/
            addMember: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;
            /**
             * Swap out the sending member for some other key `new`.
             *
             * May only be called from `Signed` origin of a current member.
             *
             * Prime membership is passed from the origin account to `new`, if extant.
             **/
            changeKey: AugmentedSubmittable<(updated: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;
            /**
             * Remove the prime member if it exists.
             *
             * May only be called from `T::PrimeOrigin`.
             **/
            clearPrime: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Remove a member `who` from the set.
             *
             * May only be called from `T::RemoveOrigin`.
             **/
            removeMember: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;
            /**
             * Change the membership to a new set, disregarding the existing membership. Be nice and
             * pass `members` pre-sorted.
             *
             * May only be called from `T::ResetOrigin`.
             **/
            resetMembers: AugmentedSubmittable<(members: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>]>;
            /**
             * Set the prime member. Must be a current member.
             *
             * May only be called from `T::PrimeOrigin`.
             **/
            setPrime: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;
            /**
             * Swap out one member `remove` for another `add`.
             *
             * May only be called from `T::SwapOrigin`.
             *
             * Prime membership is *not* passed from `remove` to `add`, if extant.
             **/
            swapMember: AugmentedSubmittable<(remove: AccountId32 | string | Uint8Array, add: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, AccountId32]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        timestamp: {
            /**
             * Set the current time.
             *
             * This call should be invoked exactly once per block. It will panic at the finalization
             * phase, if this call hasn't been invoked by that time.
             *
             * The timestamp should be greater than the previous one by the amount specified by
             * `MinimumPeriod`.
             *
             * The dispatch origin for this call must be `Inherent`.
             *
             * ## Complexity
             * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)
             * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in
             * `on_finalize`)
             * - 1 event handler `on_timestamp_set`. Must be `O(1)`.
             **/
            set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        tokens: {
            /**
             * Exactly as `transfer`, except the origin must be root and the source
             * account may be specified.
             *
             * The dispatch origin for this call must be _Root_.
             *
             * - `source`: The sender of the transfer.
             * - `dest`: The recipient of the transfer.
             * - `currency_id`: currency type.
             * - `amount`: free balance amount to tranfer.
             **/
            forceTransfer: AugmentedSubmittable<(source: AccountId32 | string | Uint8Array, dest: AccountId32 | string | Uint8Array, currencyId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, amount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, AccountId32, InterbtcPrimitivesCurrencyId, Compact<u128>]>;
            /**
             * Set the balances of a given account.
             *
             * This will alter `FreeBalance` and `ReservedBalance` in storage. it
             * will also decrease the total issuance of the system
             * (`TotalIssuance`). If the new free or reserved balance is below the
             * existential deposit, it will reap the `AccountInfo`.
             *
             * The dispatch origin for this call is `root`.
             **/
            setBalance: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array, currencyId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, newFree: Compact<u128> | AnyNumber | Uint8Array, newReserved: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, InterbtcPrimitivesCurrencyId, Compact<u128>, Compact<u128>]>;
            /**
             * Transfer some liquid free balance to another account.
             *
             * `transfer` will set the `FreeBalance` of the sender and receiver.
             * It will decrease the total issuance of the system by the
             * `TransferFee`. If the sender's account is below the existential
             * deposit as a result of the transfer, the account will be reaped.
             *
             * The dispatch origin for this call must be `Signed` by the
             * transactor.
             *
             * - `dest`: The recipient of the transfer.
             * - `currency_id`: currency type.
             * - `amount`: free balance amount to tranfer.
             **/
            transfer: AugmentedSubmittable<(dest: AccountId32 | string | Uint8Array, currencyId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, amount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, InterbtcPrimitivesCurrencyId, Compact<u128>]>;
            /**
             * Transfer all remaining balance to the given account.
             *
             * NOTE: This function only attempts to transfer _transferable_
             * balances. This means that any locked, reserved, or existential
             * deposits (when `keep_alive` is `true`), will not be transferred by
             * this function. To ensure that this function results in a killed
             * account, you might need to prepare the account by removing any
             * reference counters, storage deposits, etc...
             *
             * The dispatch origin for this call must be `Signed` by the
             * transactor.
             *
             * - `dest`: The recipient of the transfer.
             * - `currency_id`: currency type.
             * - `keep_alive`: A boolean to determine if the `transfer_all`
             * operation should send all of the funds the account has, causing
             * the sender account to be killed (false), or transfer everything
             * except at least the existential deposit, which will guarantee to
             * keep the sender account alive (true).
             **/
            transferAll: AugmentedSubmittable<(dest: AccountId32 | string | Uint8Array, currencyId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, InterbtcPrimitivesCurrencyId, bool]>;
            /**
             * Same as the [`transfer`] call, but with a check that the transfer
             * will not kill the origin account.
             *
             * 99% of the time you want [`transfer`] instead.
             *
             * The dispatch origin for this call must be `Signed` by the
             * transactor.
             *
             * - `dest`: The recipient of the transfer.
             * - `currency_id`: currency type.
             * - `amount`: free balance amount to tranfer.
             **/
            transferKeepAlive: AugmentedSubmittable<(dest: AccountId32 | string | Uint8Array, currencyId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, amount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, InterbtcPrimitivesCurrencyId, Compact<u128>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        txPause: {
            /**
             * Pause a call.
             *
             * Can only be called by [`Config::PauseOrigin`].
             * Emits an [`Event::SomethingPaused`] event on success.
             **/
            pause: AugmentedSubmittable<(fullName: ITuple<[Bytes, Option<Bytes>]> | [Bytes | string | Uint8Array, Option<Bytes> | null | Uint8Array | Bytes | string]) => SubmittableExtrinsic<ApiType>, [ITuple<[Bytes, Option<Bytes>]>]>;
            /**
             * Un-pause a call.
             *
             * Can only be called by [`Config::UnpauseOrigin`].
             * Emits an [`Event::SomethingUnpaused`] event on success.
             **/
            unpause: AugmentedSubmittable<(fullName: ITuple<[Bytes, Option<Bytes>]> | [Bytes | string | Uint8Array, Option<Bytes> | null | Uint8Array | Bytes | string]) => SubmittableExtrinsic<ApiType>, [ITuple<[Bytes, Option<Bytes>]>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        utility: {
            /**
             * Send a call through an indexed pseudonym of the sender.
             *
             * Filter from origin are passed along. The call will be dispatched with an origin which
             * use the same filter as the origin of this call.
             *
             * NOTE: If you need to ensure that any account-based filtering is not honored (i.e.
             * because you expect `proxy` to have been used prior in the call stack and you do not want
             * the call restrictions to apply to any sub-accounts), then use `as_multi_threshold_1`
             * in the Multisig pallet instead.
             *
             * NOTE: Prior to version *12, this was called `as_limited_sub`.
             *
             * The dispatch origin for this call must be _Signed_.
             **/
            asDerivative: AugmentedSubmittable<(index: u16 | AnyNumber | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u16, Call]>;
            /**
             * Send a batch of dispatch calls.
             *
             * May be called from any origin except `None`.
             *
             * - `calls`: The calls to be dispatched from the same origin. The number of call must not
             * exceed the constant: `batched_calls_limit` (available in constant metadata).
             *
             * If origin is root then the calls are dispatched without checking origin filter. (This
             * includes bypassing `frame_system::Config::BaseCallFilter`).
             *
             * ## Complexity
             * - O(C) where C is the number of calls to be batched.
             *
             * This will return `Ok` in all circumstances. To determine the success of the batch, an
             * event is deposited. If a call failed and the batch was interrupted, then the
             * `BatchInterrupted` event is deposited, along with the number of successful calls made
             * and the error of the failed call. If all were successful, then the `BatchCompleted`
             * event is deposited.
             **/
            batch: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;
            /**
             * Send a batch of dispatch calls and atomically execute them.
             * The whole transaction will rollback and fail if any of the calls failed.
             *
             * May be called from any origin except `None`.
             *
             * - `calls`: The calls to be dispatched from the same origin. The number of call must not
             * exceed the constant: `batched_calls_limit` (available in constant metadata).
             *
             * If origin is root then the calls are dispatched without checking origin filter. (This
             * includes bypassing `frame_system::Config::BaseCallFilter`).
             *
             * ## Complexity
             * - O(C) where C is the number of calls to be batched.
             **/
            batchAll: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;
            /**
             * Dispatches a function call with a provided origin.
             *
             * The dispatch origin for this call must be _Root_.
             *
             * ## Complexity
             * - O(1).
             **/
            dispatchAs: AugmentedSubmittable<(asOrigin: InterlayRuntimeParachainOriginCaller | {
                system: any;
            } | {
                Void: any;
            } | {
                TechnicalCommittee: any;
            } | {
                PolkadotXcm: any;
            } | {
                CumulusXcm: any;
            } | {
                Ethereum: any;
            } | string | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterlayRuntimeParachainOriginCaller, Call]>;
            /**
             * Send a batch of dispatch calls.
             * Unlike `batch`, it allows errors and won't interrupt.
             *
             * May be called from any origin except `None`.
             *
             * - `calls`: The calls to be dispatched from the same origin. The number of call must not
             * exceed the constant: `batched_calls_limit` (available in constant metadata).
             *
             * If origin is root then the calls are dispatch without checking origin filter. (This
             * includes bypassing `frame_system::Config::BaseCallFilter`).
             *
             * ## Complexity
             * - O(C) where C is the number of calls to be batched.
             **/
            forceBatch: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;
            /**
             * Dispatch a function call with a specified weight.
             *
             * This function does not check the weight of the call, and instead allows the
             * Root origin to specify the weight of the call.
             *
             * The dispatch origin for this call must be _Root_.
             **/
            withWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: SpWeightsWeightV2Weight | {
                refTime?: any;
                proofSize?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, SpWeightsWeightV2Weight]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        vaultAnnuity: {
            setRewardPerWrapped: AugmentedSubmittable<(rewardPerWrapped: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;
            updateRewards: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            withdrawRewards: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        vaultRegistry: {
            /**
             * Configures whether or not the vault accepts new issues.
             *
             * # Arguments
             *
             * * `origin` - sender of the transaction (i.e. the vault)
             * * `accept_new_issues` - true indicates that the vault accepts new issues
             *
             * # Weight: `O(1)`
             **/
            acceptNewIssues: AugmentedSubmittable<(currencyPair: InterbtcPrimitivesVaultCurrencyPair | {
                collateral?: any;
                wrapped?: any;
            } | string | Uint8Array, acceptNewIssues: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesVaultCurrencyPair, bool]>;
            /**
             * Recover vault ID from a liquidated status.
             *
             * # Arguments
             * * `currency_pair` - the currency pair to change
             **/
            recoverVaultId: AugmentedSubmittable<(currencyPair: InterbtcPrimitivesVaultCurrencyPair | {
                collateral?: any;
                wrapped?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesVaultCurrencyPair]>;
            /**
             * Registers a new Bitcoin address for the vault.
             *
             * # Arguments
             * * `public_key` - the BTC public key of the vault to update
             **/
            registerPublicKey: AugmentedSubmittable<(publicKey: BitcoinAddressPublicKey | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [BitcoinAddressPublicKey]>;
            /**
             * Initiates the registration procedure for a new Vault.
             * The Vault locks up collateral, which is to be used in the issuing process.
             *
             *
             * # Errors
             * * `InsufficientVaultCollateralAmount` - if the collateral is below the minimum threshold
             * * `VaultAlreadyRegistered` - if a vault is already registered for the origin account
             * * `InsufficientCollateralAvailable` - if the vault does not own enough collateral
             **/
            registerVault: AugmentedSubmittable<(currencyPair: InterbtcPrimitivesVaultCurrencyPair | {
                collateral?: any;
                wrapped?: any;
            } | string | Uint8Array, collateral: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesVaultCurrencyPair, Compact<u128>]>;
            reportUndercollateralizedVault: AugmentedSubmittable<(vaultId: InterbtcPrimitivesVaultId | {
                accountId?: any;
                currencies?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesVaultId]>;
            /**
             * Configures a custom, higher secure collateral threshold for the vault.
             *
             * # Arguments
             *
             * * `origin` - sender of the transaction (i.e. the vault)
             * * `custom_threshold` - either the threshold, or None to use the systemwide default
             *
             * # Weight: `O(1)`
             **/
            setCustomSecureThreshold: AugmentedSubmittable<(currencyPair: InterbtcPrimitivesVaultCurrencyPair | {
                collateral?: any;
                wrapped?: any;
            } | string | Uint8Array, customThreshold: Option<u128> | null | Uint8Array | u128 | AnyNumber) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesVaultCurrencyPair, Option<u128>]>;
            /**
             * Changes the collateral liquidation threshold for a currency (only executable by the Root account)
             *
             * # Arguments
             * * `currency_pair` - the currency pair to change
             * * `ceiling` - the new collateral ceiling
             **/
            setLiquidationCollateralThreshold: AugmentedSubmittable<(currencyPair: InterbtcPrimitivesVaultCurrencyPair | {
                collateral?: any;
                wrapped?: any;
            } | string | Uint8Array, threshold: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesVaultCurrencyPair, u128]>;
            /**
             * Changes the minimum amount of collateral required for registration
             * (only executable by the Root account)
             *
             * # Arguments
             * * `currency_id` - the collateral's currency id
             * * `minimum` - the new minimum collateral
             **/
            setMinimumCollateral: AugmentedSubmittable<(currencyId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, minimum: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, u128]>;
            /**
             * Changes the collateral premium redeem threshold for a currency (only executable by the Root account)
             *
             * # Arguments
             * * `currency_pair` - the currency pair to change
             * * `ceiling` - the new collateral ceiling
             **/
            setPremiumRedeemThreshold: AugmentedSubmittable<(currencyPair: InterbtcPrimitivesVaultCurrencyPair | {
                collateral?: any;
                wrapped?: any;
            } | string | Uint8Array, threshold: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesVaultCurrencyPair, u128]>;
            /**
             * Changes the secure threshold for a currency (only executable by the Root account)
             *
             * # Arguments
             * * `currency_pair` - the currency pair to change
             * * `threshold` - the new secure threshold
             **/
            setSecureCollateralThreshold: AugmentedSubmittable<(currencyPair: InterbtcPrimitivesVaultCurrencyPair | {
                collateral?: any;
                wrapped?: any;
            } | string | Uint8Array, threshold: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesVaultCurrencyPair, u128]>;
            /**
             * Changes the collateral ceiling for a currency (only executable by the Root account)
             *
             * # Arguments
             * * `currency_pair` - the currency pair to change
             * * `ceiling` - the new collateral ceiling
             **/
            setSystemCollateralCeiling: AugmentedSubmittable<(currencyPair: InterbtcPrimitivesVaultCurrencyPair | {
                collateral?: any;
                wrapped?: any;
            } | string | Uint8Array, ceiling: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesVaultCurrencyPair, u128]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        vesting: {
            claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            claimFor: AugmentedSubmittable<(dest: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;
            updateVestingSchedules: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array, vestingSchedules: Vec<OrmlVestingVestingSchedule> | (OrmlVestingVestingSchedule | {
                start?: any;
                period?: any;
                periodCount?: any;
                perPeriod?: any;
            } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [AccountId32, Vec<OrmlVestingVestingSchedule>]>;
            vestedTransfer: AugmentedSubmittable<(dest: AccountId32 | string | Uint8Array, schedule: OrmlVestingVestingSchedule | {
                start?: any;
                period?: any;
                periodCount?: any;
                perPeriod?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, OrmlVestingVestingSchedule]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        xcmpQueue: {
            /**
             * Resumes all XCM executions for the XCMP queue.
             *
             * Note that this function doesn't change the status of the in/out bound channels.
             *
             * - `origin`: Must pass `ControllerOrigin`.
             **/
            resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Services a single overweight XCM.
             *
             * - `origin`: Must pass `ExecuteOverweightOrigin`.
             * - `index`: The index of the overweight XCM to service
             * - `weight_limit`: The amount of weight that XCM execution may take.
             *
             * Errors:
             * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.
             * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.
             * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.
             *
             * Events:
             * - `OverweightServiced`: On success.
             **/
            serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: SpWeightsWeightV2Weight | {
                refTime?: any;
                proofSize?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, SpWeightsWeightV2Weight]>;
            /**
             * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.
             *
             * - `origin`: Must pass `ControllerOrigin`.
             **/
            suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Overwrites the number of pages of messages which must be in the queue after which we drop any further
             * messages from the channel.
             *
             * - `origin`: Must pass `Root`.
             * - `new`: Desired value for `QueueConfigData.drop_threshold`
             **/
            updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
            /**
             * Overwrites the number of pages of messages which the queue must be reduced to before it signals that
             * message sending may recommence after it has been suspended.
             *
             * - `origin`: Must pass `Root`.
             * - `new`: Desired value for `QueueConfigData.resume_threshold`
             **/
            updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
            /**
             * Overwrites the number of pages of messages which must be in the queue for the other side to be told to
             * suspend their sending.
             *
             * - `origin`: Must pass `Root`.
             * - `new`: Desired value for `QueueConfigData.suspend_value`
             **/
            updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
            /**
             * Overwrites the amount of remaining weight under which we stop processing messages.
             *
             * - `origin`: Must pass `Root`.
             * - `new`: Desired value for `QueueConfigData.threshold_weight`
             **/
            updateThresholdWeight: AugmentedSubmittable<(updated: SpWeightsWeightV2Weight | {
                refTime?: any;
                proofSize?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [SpWeightsWeightV2Weight]>;
            /**
             * Overwrites the speed to which the available weight approaches the maximum weight.
             * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.
             *
             * - `origin`: Must pass `Root`.
             * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.
             **/
            updateWeightRestrictDecay: AugmentedSubmittable<(updated: SpWeightsWeightV2Weight | {
                refTime?: any;
                proofSize?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [SpWeightsWeightV2Weight]>;
            /**
             * Overwrite the maximum amount of weight any individual message may consume.
             * Messages above this weight go into the overweight queue and may only be serviced explicitly.
             *
             * - `origin`: Must pass `Root`.
             * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.
             **/
            updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: SpWeightsWeightV2Weight | {
                refTime?: any;
                proofSize?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [SpWeightsWeightV2Weight]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        xTokens: {
            /**
             * Transfer native currencies.
             *
             * `dest_weight_limit` is the weight for XCM execution on the dest
             * chain, and it would be charged from the transferred assets. If set
             * below requirements, the execution may fail and assets wouldn't be
             * received.
             *
             * It's a no-op if any error on local XCM execution or message sending.
             * Note sending assets out per se doesn't guarantee they would be
             * received. Receiving depends on if the XCM message could be delivered
             * by the network, and if the receiving chain would handle
             * messages correctly.
             **/
            transfer: AugmentedSubmittable<(currencyId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array, destWeightLimit: XcmV3WeightLimit | {
                Unlimited: any;
            } | {
                Limited: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, u128, XcmVersionedMultiLocation, XcmV3WeightLimit]>;
            /**
             * Transfer `MultiAsset`.
             *
             * `dest_weight_limit` is the weight for XCM execution on the dest
             * chain, and it would be charged from the transferred assets. If set
             * below requirements, the execution may fail and assets wouldn't be
             * received.
             *
             * It's a no-op if any error on local XCM execution or message sending.
             * Note sending assets out per se doesn't guarantee they would be
             * received. Receiving depends on if the XCM message could be delivered
             * by the network, and if the receiving chain would handle
             * messages correctly.
             **/
            transferMultiasset: AugmentedSubmittable<(asset: XcmVersionedMultiAsset | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array, dest: XcmVersionedMultiLocation | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array, destWeightLimit: XcmV3WeightLimit | {
                Unlimited: any;
            } | {
                Limited: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAsset, XcmVersionedMultiLocation, XcmV3WeightLimit]>;
            /**
             * Transfer several `MultiAsset` specifying the item to be used as fee
             *
             * `dest_weight_limit` is the weight for XCM execution on the dest
             * chain, and it would be charged from the transferred assets. If set
             * below requirements, the execution may fail and assets wouldn't be
             * received.
             *
             * `fee_item` is index of the MultiAssets that we want to use for
             * payment
             *
             * It's a no-op if any error on local XCM execution or message sending.
             * Note sending assets out per se doesn't guarantee they would be
             * received. Receiving depends on if the XCM message could be delivered
             * by the network, and if the receiving chain would handle
             * messages correctly.
             **/
            transferMultiassets: AugmentedSubmittable<(assets: XcmVersionedMultiAssets | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array, feeItem: u32 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array, destWeightLimit: XcmV3WeightLimit | {
                Unlimited: any;
            } | {
                Limited: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAssets, u32, XcmVersionedMultiLocation, XcmV3WeightLimit]>;
            /**
             * Transfer `MultiAsset` specifying the fee and amount as separate.
             *
             * `dest_weight_limit` is the weight for XCM execution on the dest
             * chain, and it would be charged from the transferred assets. If set
             * below requirements, the execution may fail and assets wouldn't be
             * received.
             *
             * `fee` is the multiasset to be spent to pay for execution in
             * destination chain. Both fee and amount will be subtracted form the
             * callers balance For now we only accept fee and asset having the same
             * `MultiLocation` id.
             *
             * If `fee` is not high enough to cover for the execution costs in the
             * destination chain, then the assets will be trapped in the
             * destination chain
             *
             * It's a no-op if any error on local XCM execution or message sending.
             * Note sending assets out per se doesn't guarantee they would be
             * received. Receiving depends on if the XCM message could be delivered
             * by the network, and if the receiving chain would handle
             * messages correctly.
             **/
            transferMultiassetWithFee: AugmentedSubmittable<(asset: XcmVersionedMultiAsset | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array, fee: XcmVersionedMultiAsset | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array, dest: XcmVersionedMultiLocation | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array, destWeightLimit: XcmV3WeightLimit | {
                Unlimited: any;
            } | {
                Limited: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAsset, XcmVersionedMultiAsset, XcmVersionedMultiLocation, XcmV3WeightLimit]>;
            /**
             * Transfer several currencies specifying the item to be used as fee
             *
             * `dest_weight_limit` is the weight for XCM execution on the dest
             * chain, and it would be charged from the transferred assets. If set
             * below requirements, the execution may fail and assets wouldn't be
             * received.
             *
             * `fee_item` is index of the currencies tuple that we want to use for
             * payment
             *
             * It's a no-op if any error on local XCM execution or message sending.
             * Note sending assets out per se doesn't guarantee they would be
             * received. Receiving depends on if the XCM message could be delivered
             * by the network, and if the receiving chain would handle
             * messages correctly.
             **/
            transferMulticurrencies: AugmentedSubmittable<(currencies: Vec<ITuple<[InterbtcPrimitivesCurrencyId, u128]>> | ([InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, u128 | AnyNumber | Uint8Array])[], feeItem: u32 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array, destWeightLimit: XcmV3WeightLimit | {
                Unlimited: any;
            } | {
                Limited: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[InterbtcPrimitivesCurrencyId, u128]>>, u32, XcmVersionedMultiLocation, XcmV3WeightLimit]>;
            /**
             * Transfer native currencies specifying the fee and amount as
             * separate.
             *
             * `dest_weight_limit` is the weight for XCM execution on the dest
             * chain, and it would be charged from the transferred assets. If set
             * below requirements, the execution may fail and assets wouldn't be
             * received.
             *
             * `fee` is the amount to be spent to pay for execution in destination
             * chain. Both fee and amount will be subtracted form the callers
             * balance.
             *
             * If `fee` is not high enough to cover for the execution costs in the
             * destination chain, then the assets will be trapped in the
             * destination chain
             *
             * It's a no-op if any error on local XCM execution or message sending.
             * Note sending assets out per se doesn't guarantee they would be
             * received. Receiving depends on if the XCM message could be delivered
             * by the network, and if the receiving chain would handle
             * messages correctly.
             **/
            transferWithFee: AugmentedSubmittable<(currencyId: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array, fee: u128 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array, destWeightLimit: XcmV3WeightLimit | {
                Unlimited: any;
            } | {
                Limited: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [InterbtcPrimitivesCurrencyId, u128, u128, XcmVersionedMultiLocation, XcmV3WeightLimit]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
    }
}