import '@polkadot/api-base/types/events';
import type { ApiTypes, AugmentedEvent } from '@polkadot/api-base/types';
import type { Bytes, Null, Option, Result, U256, U8aFixed, Vec, bool, i64, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';
import type { ITuple } from '@polkadot/types-codec/types';
import type { AccountId32, H256, Weight } from '@polkadot/types/interfaces/runtime';
import type { EqClaimEthereumAddress, EqPrimitivesBalanceDepositReason, EqPrimitivesBalanceWithdrawReason, EqPrimitivesDexDeleteOrderReason, EqPrimitivesDexOrderSide, EqPrimitivesProxyProxyType, EqPrimitivesSubaccountSubAccType, EqPrimitivesTransferReason, EqStakingStakePeriod, FrameSupportScheduleLookupError, FrameSupportWeightsDispatchInfo, PalletDemocracyVoteAccountVote, PalletDemocracyVoteThreshold, PalletMultisigTimepoint, SpRuntimeDispatchError, SubstrateFixedFixedI128, XcmV1MultiLocation, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2TraitsSendError, XcmV2Xcm, XcmVersionedMultiAssets, XcmVersionedMultiLocation } from '@polkadot/types/lookup';
export declare type __AugmentedEvent<ApiType extends ApiTypes> = AugmentedEvent<ApiType>;
declare module '@polkadot/api-base/types/events' {
    interface AugmentedEvents<ApiType extends ApiTypes> {
        bailsman: {
            /**
             * Bailsman subaccount is no longer a bailsman. \[who\]
             **/
            UnregisteredBailsman: AugmentedEvent<ApiType, [AccountId32]>;
        };
        chainBridge: {
            /**
             * Allowability transfers for the chain has changed. \[chain_id, enabled\]
             **/
            ChainToggled: AugmentedEvent<ApiType, [u8, bool]>;
            /**
             * Chain now available for transfers. \[chain_id\]
             **/
            ChainWhitelisted: AugmentedEvent<ApiType, [u8]>;
            /**
             * Fee for chain has changed. \[chain_id, fee\]
             **/
            FeeChanged: AugmentedEvent<ApiType, [u8, u128]>;
            /**
             * FunglibleTransfer is for relaying fungibles. \[dest_id, nonce, resource_id, amount, recipient\]
             **/
            FungibleTransfer: AugmentedEvent<ApiType, [u8, u64, U8aFixed, U256, Bytes]>;
            /**
             * GenericTransfer is for a generic data payload. \[dest_id, nonce, resource_id, metadata\]
             **/
            GenericTransfer: AugmentedEvent<ApiType, [u8, u64, U8aFixed, Bytes]>;
            /**
             * NonFungibleTransfer is for relaying NFTS. \[dest_id, nonce, resource_id, token_id, recipient, metadata\]
             **/
            NonFungibleTransfer: AugmentedEvent<ApiType, [u8, u64, U8aFixed, Bytes, Bytes, Bytes]>;
            /**
             * Voting successful for a proposal. \[dest_id, nonce\]
             **/
            ProposalApproved: AugmentedEvent<ApiType, [u8, u64]>;
            /**
             * Execution of call failed. \[dest_id, nonce\]
             **/
            ProposalFailed: AugmentedEvent<ApiType, [u8, u64]>;
            /**
             * Proposal lifetime has changed. \[lifetime\]
             **/
            ProposalLifetimeChanged: AugmentedEvent<ApiType, [u32]>;
            /**
             * Voting rejected a proposal. \[dest_id, nonce\]
             **/
            ProposalRejected: AugmentedEvent<ApiType, [u8, u64]>;
            /**
             * Execution of call succeeded. \[dest_id, nonce\]
             **/
            ProposalSucceeded: AugmentedEvent<ApiType, [u8, u64]>;
            /**
             * Relayer added to set. \[who\]
             **/
            RelayerAdded: AugmentedEvent<ApiType, [AccountId32]>;
            /**
             * Relayer removed from set. \[who\]
             **/
            RelayerRemoved: AugmentedEvent<ApiType, [AccountId32]>;
            /**
             * Vote threshold has changed. \[new_threshold\]
             **/
            RelayerThresholdChanged: AugmentedEvent<ApiType, [u32]>;
            /**
             * Vot submitted against proposal. \[dest_id, nonce, who\]
             **/
            VoteAgainst: AugmentedEvent<ApiType, [u8, u64, AccountId32]>;
            /**
             * Vote submitted in favour of proposal. \[dest_id, nonce, who\]
             **/
            VoteFor: AugmentedEvent<ApiType, [u8, u64, AccountId32]>;
        };
        claims: {
            /**
             * `AccountId` claimed `Balance` amount of currency reserved for `EthereumAddress`
             * \[who, ethereum_account, amount\]
             **/
            Claimed: AugmentedEvent<ApiType, [AccountId32, EqClaimEthereumAddress, u128]>;
        };
        council: {
            /**
             * A motion was approved by the required threshold.
             **/
            Approved: AugmentedEvent<ApiType, [proposalHash: H256], {
                proposalHash: H256;
            }>;
            /**
             * A proposal was closed because its threshold was reached or after its duration was up.
             **/
            Closed: AugmentedEvent<ApiType, [proposalHash: H256, yes: u32, no: u32], {
                proposalHash: H256;
                yes: u32;
                no: u32;
            }>;
            /**
             * A motion was not approved by the required threshold.
             **/
            Disapproved: AugmentedEvent<ApiType, [proposalHash: H256], {
                proposalHash: H256;
            }>;
            /**
             * A motion was executed; result will be `Ok` if it returned without error.
             **/
            Executed: AugmentedEvent<ApiType, [proposalHash: H256, result: Result<Null, SpRuntimeDispatchError>], {
                proposalHash: H256;
                result: Result<Null, SpRuntimeDispatchError>;
            }>;
            /**
             * A single member did some action; result will be `Ok` if it returned without error.
             **/
            MemberExecuted: AugmentedEvent<ApiType, [proposalHash: H256, result: Result<Null, SpRuntimeDispatchError>], {
                proposalHash: H256;
                result: Result<Null, SpRuntimeDispatchError>;
            }>;
            /**
             * A motion (given hash) has been proposed (by given account) with a threshold (given
             * `MemberCount`).
             **/
            Proposed: AugmentedEvent<ApiType, [account: AccountId32, proposalIndex: u32, proposalHash: H256, threshold: u32], {
                account: AccountId32;
                proposalIndex: u32;
                proposalHash: H256;
                threshold: u32;
            }>;
            /**
             * A motion (given hash) has been voted on by given account, leaving
             * a tally (yes votes and no votes given respectively as `MemberCount`).
             **/
            Voted: AugmentedEvent<ApiType, [account: AccountId32, proposalHash: H256, voted: bool, yes: u32, no: u32], {
                account: AccountId32;
                proposalHash: H256;
                voted: bool;
                yes: u32;
                no: u32;
            }>;
        };
        councilMembership: {
            /**
             * Phantom member, never used.
             **/
            Dummy: AugmentedEvent<ApiType, []>;
            /**
             * One of the members' keys changed.
             **/
            KeyChanged: AugmentedEvent<ApiType, []>;
            /**
             * The given member was added; see the transaction for who.
             **/
            MemberAdded: AugmentedEvent<ApiType, []>;
            /**
             * The given member was removed; see the transaction for who.
             **/
            MemberRemoved: AugmentedEvent<ApiType, []>;
            /**
             * The membership was reset; see the transaction for who the new set is.
             **/
            MembersReset: AugmentedEvent<ApiType, []>;
            /**
             * Two members were swapped; see the transaction for who.
             **/
            MembersSwapped: AugmentedEvent<ApiType, []>;
        };
        curveAmm: {
            /**
             * Liquidity added into the pool `PoolId` by `T::AccountId`.
             *
             * Included values are:
             * - account identifier `T::AccountId`
             * - pool identifier `PoolId`
             * - added token amounts `Vec<T::Balance>`
             * - charged fees `Vec<T::Balance>`
             * - actual invariant `T::Balance`
             * - actual token supply `T::Balance`
             * - minted amount `T::Balance`
             *
             * \[who, pool_id, token_amounts, fees, invariant, token_supply, mint_amount\]
             **/
            AddLiquidity: AugmentedEvent<ApiType, [AccountId32, u32, Vec<u128>, Vec<u128>, u128, u128, u128]>;
            /**
             * Pool with specified id `PoolId` was created successfully by `T::AccountId`.
             *
             * Included values are:
             * - account identifier `T::AccountId`
             * - pool identifier `PoolId`
             *
             * \[who, pool_id\]
             **/
            CreatePool: AugmentedEvent<ApiType, [AccountId32, u32]>;
            /**
             * Liquidity removed from pool `PoolId` by `T::AccountId` in balanced way.
             *
             * Included values are:
             * - account identifier `T::AccountId`
             * - pool identifier `PoolId`
             * - removed token amounts `Vec<T::Balance>`
             * - charged fees `Vec<T::Balance>`
             * - actual token supply `T::Balance`
             * - quantity of LP tokens to burn in the withdrawal `T::Balance`
             *
             * \[who, pool_id, token_amounts, fees, token_supply, burn_amount\]
             **/
            RemoveLiquidity: AugmentedEvent<ApiType, [AccountId32, u32, Vec<u128>, Vec<u128>, u128, u128]>;
            /**
             * Liquidity removed from pool `PoolId` by `T::AccountId` in imbalanced way.
             *
             * Included values are:
             * - account identifier `T::AccountId`
             * - pool identifier `PoolId`
             * - removed token amounts `Vec<T::Balance>`
             * - charged fees `Vec<T::Balance>`
             * - actual invariant `T::Balance`
             * - actual token supply `T::Balance`
             * - removed LP token amount `T::Balance`
             *
             * \[who, pool_id, token_amounts, fees, invariant, token_supply, burn_amount\]
             **/
            RemoveLiquidityImbalance: AugmentedEvent<ApiType, [AccountId32, u32, Vec<u128>, Vec<u128>, u128, u128, u128]>;
            /**
             * Liquidity removed from pool `PoolId` only for one token.
             *
             * Included values are:
             * - account identifier `T::AccountId`
             * - pool identifier `PoolId`
             * - removed token amount `T::Balance`
             * - received token index `PoolTokenIndex`
             * - received token amount `T::Balance`
             * - actual token supply `T::Balance`
             * - charged fee `T::Balance`
             *
             * \[who, pool_id, burn_amount, received_token, received_amount, token_supply, fee\]
             **/
            RemoveLiquidityOne: AugmentedEvent<ApiType, [AccountId32, u32, u128, u32, u128, u128, u128]>;
            /**
             * Token exchange happened.
             *
             * Included values are:
             * - account identifier `T::AccountId`
             * - pool identifier `PoolId`
             * - index of sent token `PoolTokenIndex`
             * - amount of sent token `T::Balance`
             * - index of received token `PoolTokenIndex`
             * - amount of received token `T::Balance`
             * - charged fee `T::Balance`
             *
             * \[who, pool_id, sent_token_index, sent_amount, received_token_index, received_amount, fee\]
             **/
            TokenExchange: AugmentedEvent<ApiType, [AccountId32, u32, u32, u128, u32, u128, u128]>;
            /**
             * Withdraw admin fees `Vec<T::Balance>` from pool `PoolId` by user `T::AccountId`
             *
             * Included values are:
             * - account identifier `T::AccountId`
             * - pool identifier `PoolId`
             * - withdrew admin fees `Vec<T::Balance>`
             *
             * [who, pool_id, admin_fees]
             **/
            WithdrawAdminFees: AugmentedEvent<ApiType, [AccountId32, u32, Vec<u128>]>;
        };
        democracy: {
            /**
             * A proposal_hash has been blacklisted permanently.
             **/
            Blacklisted: AugmentedEvent<ApiType, [proposalHash: H256], {
                proposalHash: H256;
            }>;
            /**
             * A referendum has been cancelled.
             **/
            Cancelled: AugmentedEvent<ApiType, [refIndex: u32], {
                refIndex: u32;
            }>;
            /**
             * An account has delegated their vote to another account.
             **/
            Delegated: AugmentedEvent<ApiType, [who: AccountId32, target: AccountId32], {
                who: AccountId32;
                target: AccountId32;
            }>;
            /**
             * A proposal has been enacted.
             **/
            Executed: AugmentedEvent<ApiType, [refIndex: u32, result: Result<Null, SpRuntimeDispatchError>], {
                refIndex: u32;
                result: Result<Null, SpRuntimeDispatchError>;
            }>;
            /**
             * An external proposal has been tabled.
             **/
            ExternalTabled: AugmentedEvent<ApiType, []>;
            /**
             * A proposal has been rejected by referendum.
             **/
            NotPassed: AugmentedEvent<ApiType, [refIndex: u32], {
                refIndex: u32;
            }>;
            /**
             * A proposal has been approved by referendum.
             **/
            Passed: AugmentedEvent<ApiType, [refIndex: u32], {
                refIndex: u32;
            }>;
            /**
             * A proposal could not be executed because its preimage was invalid.
             **/
            PreimageInvalid: AugmentedEvent<ApiType, [proposalHash: H256, refIndex: u32], {
                proposalHash: H256;
                refIndex: u32;
            }>;
            /**
             * A proposal could not be executed because its preimage was missing.
             **/
            PreimageMissing: AugmentedEvent<ApiType, [proposalHash: H256, refIndex: u32], {
                proposalHash: H256;
                refIndex: u32;
            }>;
            /**
             * A proposal's preimage was noted, and the deposit taken.
             **/
            PreimageNoted: AugmentedEvent<ApiType, [proposalHash: H256, who: AccountId32, deposit: u128], {
                proposalHash: H256;
                who: AccountId32;
                deposit: u128;
            }>;
            /**
             * A registered preimage was removed and the deposit collected by the reaper.
             **/
            PreimageReaped: AugmentedEvent<ApiType, [proposalHash: H256, provider: AccountId32, deposit: u128, reaper: AccountId32], {
                proposalHash: H256;
                provider: AccountId32;
                deposit: u128;
                reaper: AccountId32;
            }>;
            /**
             * A proposal preimage was removed and used (the deposit was returned).
             **/
            PreimageUsed: AugmentedEvent<ApiType, [proposalHash: H256, provider: AccountId32, deposit: u128], {
                proposalHash: H256;
                provider: AccountId32;
                deposit: u128;
            }>;
            /**
             * A proposal got canceled.
             **/
            ProposalCanceled: AugmentedEvent<ApiType, [propIndex: u32], {
                propIndex: u32;
            }>;
            /**
             * A motion has been proposed by a public account.
             **/
            Proposed: AugmentedEvent<ApiType, [proposalIndex: u32, deposit: u128], {
                proposalIndex: u32;
                deposit: u128;
            }>;
            /**
             * An account has secconded a proposal
             **/
            Seconded: AugmentedEvent<ApiType, [seconder: AccountId32, propIndex: u32], {
                seconder: AccountId32;
                propIndex: u32;
            }>;
            /**
             * A referendum has begun.
             **/
            Started: AugmentedEvent<ApiType, [refIndex: u32, threshold: PalletDemocracyVoteThreshold], {
                refIndex: u32;
                threshold: PalletDemocracyVoteThreshold;
            }>;
            /**
             * A public proposal has been tabled for referendum vote.
             **/
            Tabled: AugmentedEvent<ApiType, [proposalIndex: u32, deposit: u128, depositors: Vec<AccountId32>], {
                proposalIndex: u32;
                deposit: u128;
                depositors: Vec<AccountId32>;
            }>;
            /**
             * An account has cancelled a previous delegation operation.
             **/
            Undelegated: AugmentedEvent<ApiType, [account: AccountId32], {
                account: AccountId32;
            }>;
            /**
             * An external proposal has been vetoed.
             **/
            Vetoed: AugmentedEvent<ApiType, [who: AccountId32, proposalHash: H256, until: u32], {
                who: AccountId32;
                proposalHash: H256;
                until: u32;
            }>;
            /**
             * An account has voted in a referendum
             **/
            Voted: AugmentedEvent<ApiType, [voter: AccountId32, refIndex: u32, vote: PalletDemocracyVoteAccountVote], {
                voter: AccountId32;
                refIndex: u32;
                vote: PalletDemocracyVoteAccountVote;
            }>;
        };
        dmpQueue: {
            /**
             * Downward message executed with the given outcome.
             **/
            ExecutedDownward: AugmentedEvent<ApiType, [messageId: U8aFixed, outcome: XcmV2TraitsOutcome], {
                messageId: U8aFixed;
                outcome: XcmV2TraitsOutcome;
            }>;
            /**
             * Downward message is invalid XCM.
             **/
            InvalidFormat: AugmentedEvent<ApiType, [messageId: U8aFixed], {
                messageId: U8aFixed;
            }>;
            /**
             * Downward message is overweight and was placed in the overweight queue.
             **/
            OverweightEnqueued: AugmentedEvent<ApiType, [messageId: U8aFixed, overweightIndex: u64, requiredWeight: Weight], {
                messageId: U8aFixed;
                overweightIndex: u64;
                requiredWeight: Weight;
            }>;
            /**
             * Downward message from the overweight queue was executed.
             **/
            OverweightServiced: AugmentedEvent<ApiType, [overweightIndex: u64, weightUsed: Weight], {
                overweightIndex: u64;
                weightUsed: Weight;
            }>;
            /**
             * Downward message is unsupported version of XCM.
             **/
            UnsupportedVersion: AugmentedEvent<ApiType, [messageId: U8aFixed], {
                messageId: U8aFixed;
            }>;
            /**
             * The weight limit for handling downward messages was reached.
             **/
            WeightExhausted: AugmentedEvent<ApiType, [messageId: U8aFixed, remainingWeight: Weight, requiredWeight: Weight], {
                messageId: U8aFixed;
                remainingWeight: Weight;
                requiredWeight: Weight;
            }>;
        };
        eqAssets: {
            /**
             * Asset removed from store \[asset, asset_name\]
             **/
            DeleteAsset: AugmentedEvent<ApiType, [u64, Bytes]>;
            /**
             * New asset added to store  \[asset, asset_name\]
             **/
            NewAsset: AugmentedEvent<ApiType, [u64, Bytes]>;
            /**
             * Asset updated in the store \[asset, asset_name\]
             **/
            UpdateAsset: AugmentedEvent<ApiType, [u64, Bytes]>;
        };
        eqBalances: {
            /**
             * Delete account event. \[who\]
             **/
            DeleteAccount: AugmentedEvent<ApiType, [AccountId32]>;
            /**
             * Deposit event. Included values are:
             * - to `AccountId`
             * - transfer `Asset`
             * - transferred amount
             * - reason to deposit
             * \[to, asset, amount, reason\]
             **/
            Deposit: AugmentedEvent<ApiType, [AccountId32, u64, u128, EqPrimitivesBalanceDepositReason]>;
            /**
             * Exchange event. Included values are:
             * - accounts that perform exchange
             * - exchanged assets
             * - exchanged amounts
             * \[account_1, asset_1, amount_1, account_2, asset_2, amount_2\]
             **/
            Exchange: AugmentedEvent<ApiType, [AccountId32, u64, u128, AccountId32, u64, u128]>;
            MigrationComplete: AugmentedEvent<ApiType, []>;
            /**
             * Transfer event. Included values are:
             * - from `AccountId`
             * - to `AccountId`
             * - transfer `Asset`
             * - transferred amount
             * - transfer reason
             * \[from, to, asset, amount, reason\]
             **/
            Transfer: AugmentedEvent<ApiType, [AccountId32, AccountId32, u64, u128, EqPrimitivesTransferReason]>;
            /**
             * Withdraw event. Included values are:
             * - from `AccountId`
             * - transfer `Asset`
             * - transferred amount
             * \[from, asset, amount\]
             **/
            Withdraw: AugmentedEvent<ApiType, [AccountId32, u64, u128, EqPrimitivesBalanceWithdrawReason]>;
            /**
             * XCM sending error
             * - send_error `xcm::latest::SendError`
             * \[send_error\]
             **/
            XcmMessageSendError: AugmentedEvent<ApiType, [XcmV2TraitsSendError]>;
            /**
             * XCM message sent
             * - dest `MultiLocation`
             * \[dest\]
             **/
            XcmTransfer: AugmentedEvent<ApiType, [XcmV1MultiLocation]>;
        };
        eqBridge: {
            /**
             * Transfers funds from the bridge into the network
             **/
            FromBridgeTransfer: AugmentedEvent<ApiType, [AccountId32, u64, u128]>;
            /**
             * Transfers funds from the bridge into the network to transfer next
             **/
            FromBridgeTransferNext: AugmentedEvent<ApiType, [Bytes, u64, u128]>;
            /**
             * Minimum transfer amount to out of the network has changed. \[chainId, resourceId, new_minimum_amount\]
             **/
            MinimumTransferAmountChanged: AugmentedEvent<ApiType, [u8, U8aFixed, u128]>;
            /**
             * Demonstrate an arbitrary call from a proposal. \[hash\]
             **/
            Remark: AugmentedEvent<ApiType, [H256]>;
            /**
             * Transfers funds out of the network to the bridge
             **/
            ToBridgeTransfer: AugmentedEvent<ApiType, [AccountId32, u64, u128]>;
            /**
             * Allowability withdrawals for the resource id to chain has changed. \[resource_id, chain_id, enabled\]
             **/
            WithdrawalsToggled: AugmentedEvent<ApiType, [U8aFixed, u8, bool]>;
        };
        eqDex: {
            /**
             * Orders matched
             * `[asset, taker_rest, maker_price, maker_order_id, maker, taker, maker_fee, taker_fee, exchange_amount, maker_side]`
             **/
            Match: AugmentedEvent<ApiType, [u64, u128, i64, u64, AccountId32, AccountId32, u128, u128, u128, EqPrimitivesDexOrderSide]>;
            /**
             * Order was created
             * `[subaccount_id, order_id, asset, amount, price, side, created_at, expiration_time]`
             **/
            OrderCreated: AugmentedEvent<ApiType, [AccountId32, u64, u64, u128, i64, EqPrimitivesDexOrderSide, u64, u64]>;
            /**
             * Order was deleted
             * `[account_id, order_id, asset, reason]`
             **/
            OrderDeleted: AugmentedEvent<ApiType, [AccountId32, u64, u64, EqPrimitivesDexDeleteOrderReason]>;
        };
        eqLending: {
            Deposit: AugmentedEvent<ApiType, [who: AccountId32, asset: u64, value: u128], {
                who: AccountId32;
                asset: u64;
                value: u128;
            }>;
            Payout: AugmentedEvent<ApiType, [who: AccountId32, asset: u64, payout: u128], {
                who: AccountId32;
                asset: u64;
                payout: u128;
            }>;
            Withdraw: AugmentedEvent<ApiType, [who: AccountId32, asset: u64, value: u128], {
                who: AccountId32;
                asset: u64;
                value: u128;
            }>;
        };
        eqLockdrop: {
            /**
             * User `who` locks `amount` of Eq
             * \[who, amount\]
             **/
            Lock: AugmentedEvent<ApiType, [AccountId32, u128]>;
            /**
             * User `who` unlocks `amount` of Eq
             * \[who, amount\]
             **/
            Unlock: AugmentedEvent<ApiType, [AccountId32, u128]>;
        };
        eqMarginCall: {
            /**
             * Event is fired when an account achieves the `maintenance_margin` level.
             * \[main_acc, maybe(subacc_type,subacc_id), timer\]
             **/
            MaintenanceMarginCall: AugmentedEvent<ApiType, [AccountId32, Option<ITuple<[EqPrimitivesSubaccountSubAccType, AccountId32]>>, u64]>;
            /**
             * Event is fired when an account is liquidated.
             * \[main_acc, maybe(subacc_type,subacc_id)\]
             **/
            MarginCallExecuted: AugmentedEvent<ApiType, [AccountId32, Option<ITuple<[EqPrimitivesSubaccountSubAccType, AccountId32]>>]>;
        };
        eqMarketMaker: {
            /**
             * `AccountId` was added to the whitelist. \[who\]
             **/
            AddedToWhitelist: AugmentedEvent<ApiType, [AccountId32]>;
            /**
             * `AccountId` was removed from the whitelist. \[who\]
             **/
            RemovedFromWhitelist: AugmentedEvent<ApiType, [AccountId32]>;
        };
        eqMultisigSudo: {
            /**
             * The storage has been initialized
             **/
            Initialized: AugmentedEvent<ApiType, []>;
            /**
             * A key has been added to the multisig signatory list
             **/
            KeyAdded: AugmentedEvent<ApiType, [AccountId32]>;
            /**
             * A key has been removed to the multisig signatory list
             **/
            KeyRemoved: AugmentedEvent<ApiType, [AccountId32]>;
            /**
             * Sudo was executed on the proposal after enough signatures
             **/
            MultisigSudid: AugmentedEvent<ApiType, [U8aFixed, Result<Null, SpRuntimeDispatchError>]>;
            /**
             * A new multisig proposal
             **/
            NewProposal: AugmentedEvent<ApiType, [AccountId32, U8aFixed]>;
            /**
             * The proposal was approved
             **/
            ProposalApproved: AugmentedEvent<ApiType, [AccountId32, U8aFixed]>;
            /**
             * The proposal was cancelled
             **/
            ProposalCancelled: AugmentedEvent<ApiType, [U8aFixed]>;
            /**
             * Sudo critical failure
             **/
            SudoFailed: AugmentedEvent<ApiType, [U8aFixed]>;
            /**
             * The signatory threshold was modified; a new value is supplied.
             **/
            ThresholdModified: AugmentedEvent<ApiType, [u32]>;
        };
        eqSessionManager: {
            /**
             * Validator successfully added
             * \[who\]
             **/
            ValidatorAdded: AugmentedEvent<ApiType, [AccountId32]>;
            /**
             * Validator successfully removed
             * \[who\]
             **/
            ValidatorRemoved: AugmentedEvent<ApiType, [AccountId32]>;
        };
        eqStaking: {
            Staked: AugmentedEvent<ApiType, [who: AccountId32, amount: u128, period: EqStakingStakePeriod], {
                who: AccountId32;
                amount: u128;
                period: EqStakingStakePeriod;
            }>;
        };
        financial: {
            /**
             * Financial metrics for the specified asset have been recalculated
             * \[asset\]
             **/
            AssetMetricsRecalculated: AugmentedEvent<ApiType, [u64]>;
            /**
             * Financial metrics for all assets have been recalculated
             **/
            MetricsRecalculated: AugmentedEvent<ApiType, []>;
            /**
             * Financial metrics for the specified portfolio have been recalculated
             * \[portfolio\]
             **/
            PortfolioMetricsRecalculated: AugmentedEvent<ApiType, [AccountId32]>;
        };
        migration: {
            /**
             * Migration completed
             **/
            Migrated: AugmentedEvent<ApiType, []>;
            /**
             * Migration processed N items
             **/
            MigrationProcessed: AugmentedEvent<ApiType, [u16]>;
            /**
             * New migration with N length added
             **/
            MigrationSetted: AugmentedEvent<ApiType, [u16]>;
        };
        multisig: {
            /**
             * A multisig operation has been approved by someone.
             **/
            MultisigApproval: AugmentedEvent<ApiType, [approving: AccountId32, timepoint: PalletMultisigTimepoint, multisig: AccountId32, callHash: U8aFixed], {
                approving: AccountId32;
                timepoint: PalletMultisigTimepoint;
                multisig: AccountId32;
                callHash: U8aFixed;
            }>;
            /**
             * A multisig operation has been cancelled.
             **/
            MultisigCancelled: AugmentedEvent<ApiType, [cancelling: AccountId32, timepoint: PalletMultisigTimepoint, multisig: AccountId32, callHash: U8aFixed], {
                cancelling: AccountId32;
                timepoint: PalletMultisigTimepoint;
                multisig: AccountId32;
                callHash: U8aFixed;
            }>;
            /**
             * A multisig operation has been executed.
             **/
            MultisigExecuted: AugmentedEvent<ApiType, [approving: AccountId32, timepoint: PalletMultisigTimepoint, multisig: AccountId32, callHash: U8aFixed, result: Result<Null, SpRuntimeDispatchError>], {
                approving: AccountId32;
                timepoint: PalletMultisigTimepoint;
                multisig: AccountId32;
                callHash: U8aFixed;
                result: Result<Null, SpRuntimeDispatchError>;
            }>;
            /**
             * A new multisig operation has begun.
             **/
            NewMultisig: AugmentedEvent<ApiType, [approving: AccountId32, multisig: AccountId32, callHash: U8aFixed], {
                approving: AccountId32;
                multisig: AccountId32;
                callHash: U8aFixed;
            }>;
        };
        oracle: {
            /**
             * A new price added to the storage. The event contains: `Asset` for the price,
             * `FixedI64` for the price value that was added, `FixedI64` for a new
             * aggregated price and `AccountId` of the price submitter
             * \[asset, new_value, aggregated, submitter\]
             **/
            NewPrice: AugmentedEvent<ApiType, [u64, i64, i64, AccountId32]>;
        };
        parachainSystem: {
            /**
             * Downward messages were processed using the given weight.
             **/
            DownwardMessagesProcessed: AugmentedEvent<ApiType, [weightUsed: Weight, dmqHead: H256], {
                weightUsed: Weight;
                dmqHead: H256;
            }>;
            /**
             * Some downward messages have been received and will be processed.
             **/
            DownwardMessagesReceived: AugmentedEvent<ApiType, [count: u32], {
                count: u32;
            }>;
            /**
             * An upgrade has been authorized.
             **/
            UpgradeAuthorized: AugmentedEvent<ApiType, [codeHash: H256], {
                codeHash: H256;
            }>;
            /**
             * The validation function was applied as of the contained relay chain block number.
             **/
            ValidationFunctionApplied: AugmentedEvent<ApiType, [relayChainBlockNum: u32], {
                relayChainBlockNum: u32;
            }>;
            /**
             * The relay-chain aborted the upgrade process.
             **/
            ValidationFunctionDiscarded: AugmentedEvent<ApiType, []>;
            /**
             * The validation function has been scheduled to apply.
             **/
            ValidationFunctionStored: AugmentedEvent<ApiType, []>;
        };
        polkadotXcm: {
            /**
             * Some assets have been placed in an asset trap.
             *
             * \[ hash, origin, assets \]
             **/
            AssetsTrapped: AugmentedEvent<ApiType, [H256, XcmV1MultiLocation, XcmVersionedMultiAssets]>;
            /**
             * Execution of an XCM message was attempted.
             *
             * \[ outcome \]
             **/
            Attempted: AugmentedEvent<ApiType, [XcmV2TraitsOutcome]>;
            /**
             * Expected query response has been received but the origin location of the response does
             * not match that expected. The query remains registered for a later, valid, response to
             * be received and acted upon.
             *
             * \[ origin location, id, expected location \]
             **/
            InvalidResponder: AugmentedEvent<ApiType, [XcmV1MultiLocation, u64, Option<XcmV1MultiLocation>]>;
            /**
             * Expected query response has been received but the expected origin location placed in
             * storage by this runtime previously cannot be decoded. The query remains registered.
             *
             * This is unexpected (since a location placed in storage in a previously executing
             * runtime should be readable prior to query timeout) and dangerous since the possibly
             * valid response will be dropped. Manual governance intervention is probably going to be
             * needed.
             *
             * \[ origin location, id \]
             **/
            InvalidResponderVersion: AugmentedEvent<ApiType, [XcmV1MultiLocation, u64]>;
            /**
             * Query response has been received and query is removed. The registered notification has
             * been dispatched and executed successfully.
             *
             * \[ id, pallet index, call index \]
             **/
            Notified: AugmentedEvent<ApiType, [u64, u8, u8]>;
            /**
             * Query response has been received and query is removed. The dispatch was unable to be
             * decoded into a `Call`; this might be due to dispatch function having a signature which
             * is not `(origin, QueryId, Response)`.
             *
             * \[ id, pallet index, call index \]
             **/
            NotifyDecodeFailed: AugmentedEvent<ApiType, [u64, u8, u8]>;
            /**
             * Query response has been received and query is removed. There was a general error with
             * dispatching the notification call.
             *
             * \[ id, pallet index, call index \]
             **/
            NotifyDispatchError: AugmentedEvent<ApiType, [u64, u8, u8]>;
            /**
             * Query response has been received and query is removed. The registered notification could
             * not be dispatched because the dispatch weight is greater than the maximum weight
             * originally budgeted by this runtime for the query result.
             *
             * \[ id, pallet index, call index, actual weight, max budgeted weight \]
             **/
            NotifyOverweight: AugmentedEvent<ApiType, [u64, u8, u8, Weight, Weight]>;
            /**
             * A given location which had a version change subscription was dropped owing to an error
             * migrating the location to our new XCM format.
             *
             * \[ location, query ID \]
             **/
            NotifyTargetMigrationFail: AugmentedEvent<ApiType, [XcmVersionedMultiLocation, u64]>;
            /**
             * A given location which had a version change subscription was dropped owing to an error
             * sending the notification to it.
             *
             * \[ location, query ID, error \]
             **/
            NotifyTargetSendFail: AugmentedEvent<ApiType, [XcmV1MultiLocation, u64, XcmV2TraitsError]>;
            /**
             * Query response has been received and is ready for taking with `take_response`. There is
             * no registered notification call.
             *
             * \[ id, response \]
             **/
            ResponseReady: AugmentedEvent<ApiType, [u64, XcmV2Response]>;
            /**
             * Received query response has been read and removed.
             *
             * \[ id \]
             **/
            ResponseTaken: AugmentedEvent<ApiType, [u64]>;
            /**
             * A XCM message was sent.
             *
             * \[ origin, destination, message \]
             **/
            Sent: AugmentedEvent<ApiType, [XcmV1MultiLocation, XcmV1MultiLocation, XcmV2Xcm]>;
            /**
             * The supported version of a location has been changed. This might be through an
             * automatic notification or a manual intervention.
             *
             * \[ location, XCM version \]
             **/
            SupportedVersionChanged: AugmentedEvent<ApiType, [XcmV1MultiLocation, u32]>;
            /**
             * Query response received which does not match a registered query. This may be because a
             * matching query was never registered, it may be because it is a duplicate response, or
             * because the query timed out.
             *
             * \[ origin location, id \]
             **/
            UnexpectedResponse: AugmentedEvent<ApiType, [XcmV1MultiLocation, u64]>;
            /**
             * An XCM version change notification message has been attempted to be sent.
             *
             * \[ destination, result \]
             **/
            VersionChangeNotified: AugmentedEvent<ApiType, [XcmV1MultiLocation, u32]>;
        };
        preimage: {
            /**
             * A preimage has ben cleared.
             **/
            Cleared: AugmentedEvent<ApiType, [hash_: H256], {
                hash_: H256;
            }>;
            /**
             * A preimage has been noted.
             **/
            Noted: AugmentedEvent<ApiType, [hash_: H256], {
                hash_: H256;
            }>;
            /**
             * A preimage has been requested.
             **/
            Requested: AugmentedEvent<ApiType, [hash_: H256], {
                hash_: H256;
            }>;
        };
        proxy: {
            /**
             * An announcement was placed to make a call in the future.
             **/
            Announced: AugmentedEvent<ApiType, [real: AccountId32, proxy: AccountId32, callHash: H256], {
                real: AccountId32;
                proxy: AccountId32;
                callHash: H256;
            }>;
            /**
             * Anonymous account has been created by new proxy with given
             * disambiguation index and proxy type.
             **/
            AnonymousCreated: AugmentedEvent<ApiType, [anonymous: AccountId32, who: AccountId32, proxyType: EqPrimitivesProxyProxyType, disambiguationIndex: u16], {
                anonymous: AccountId32;
                who: AccountId32;
                proxyType: EqPrimitivesProxyProxyType;
                disambiguationIndex: u16;
            }>;
            /**
             * A proxy was added.
             **/
            ProxyAdded: AugmentedEvent<ApiType, [delegator: AccountId32, delegatee: AccountId32, proxyType: EqPrimitivesProxyProxyType, delay: u32], {
                delegator: AccountId32;
                delegatee: AccountId32;
                proxyType: EqPrimitivesProxyProxyType;
                delay: u32;
            }>;
            /**
             * A proxy was executed correctly, with the given.
             **/
            ProxyExecuted: AugmentedEvent<ApiType, [result: Result<Null, SpRuntimeDispatchError>], {
                result: Result<Null, SpRuntimeDispatchError>;
            }>;
            /**
             * A proxy was removed.
             **/
            ProxyRemoved: AugmentedEvent<ApiType, [delegator: AccountId32, delegatee: AccountId32, proxyType: EqPrimitivesProxyProxyType, delay: u32], {
                delegator: AccountId32;
                delegatee: AccountId32;
                proxyType: EqPrimitivesProxyProxyType;
                delay: u32;
            }>;
        };
        scheduler: {
            /**
             * The call for the provided hash was not found so the task has been aborted.
             **/
            CallLookupFailed: AugmentedEvent<ApiType, [task: ITuple<[u32, u32]>, id: Option<Bytes>, error: FrameSupportScheduleLookupError], {
                task: ITuple<[u32, u32]>;
                id: Option<Bytes>;
                error: FrameSupportScheduleLookupError;
            }>;
            /**
             * Canceled some task.
             **/
            Canceled: AugmentedEvent<ApiType, [when: u32, index: u32], {
                when: u32;
                index: u32;
            }>;
            /**
             * Dispatched some task.
             **/
            Dispatched: AugmentedEvent<ApiType, [task: ITuple<[u32, u32]>, id: Option<Bytes>, result: Result<Null, SpRuntimeDispatchError>], {
                task: ITuple<[u32, u32]>;
                id: Option<Bytes>;
                result: Result<Null, SpRuntimeDispatchError>;
            }>;
            /**
             * Scheduled some task.
             **/
            Scheduled: AugmentedEvent<ApiType, [when: u32, index: u32], {
                when: u32;
                index: u32;
            }>;
        };
        session: {
            /**
             * New session has happened. Note that the argument is the session index, not the
             * block number as the type might suggest.
             **/
            NewSession: AugmentedEvent<ApiType, [sessionIndex: u32], {
                sessionIndex: u32;
            }>;
        };
        subaccounts: {
            /**
             * Register bailsman subaccount as bailsman
             * - first element is subaccount owner's `AccountId`
             * - second element is subaccount of type Bailsman
             * \[owner, subaccount\]
             **/
            RegisterBailsman: AugmentedEvent<ApiType, [AccountId32, AccountId32]>;
            /**
             * New subaccount created
             * - first element is subaccount owner's `AccountId`
             * - second element is `AccountId` of created subaccount
             * - last element is a type of created subaccount
             * \[owner, subaccount, type\]
             **/
            SubaccountCreated: AugmentedEvent<ApiType, [AccountId32, AccountId32, EqPrimitivesSubaccountSubAccType]>;
        };
        system: {
            /**
             * `:code` was updated.
             **/
            CodeUpdated: AugmentedEvent<ApiType, []>;
            /**
             * An extrinsic failed.
             **/
            ExtrinsicFailed: AugmentedEvent<ApiType, [dispatchError: SpRuntimeDispatchError, dispatchInfo: FrameSupportWeightsDispatchInfo], {
                dispatchError: SpRuntimeDispatchError;
                dispatchInfo: FrameSupportWeightsDispatchInfo;
            }>;
            /**
             * An extrinsic completed successfully.
             **/
            ExtrinsicSuccess: AugmentedEvent<ApiType, [dispatchInfo: FrameSupportWeightsDispatchInfo], {
                dispatchInfo: FrameSupportWeightsDispatchInfo;
            }>;
            /**
             * An account was reaped.
             **/
            KilledAccount: AugmentedEvent<ApiType, [account: AccountId32], {
                account: AccountId32;
            }>;
            /**
             * A new account was created.
             **/
            NewAccount: AugmentedEvent<ApiType, [account: AccountId32], {
                account: AccountId32;
            }>;
            /**
             * On on-chain remark happened.
             **/
            Remarked: AugmentedEvent<ApiType, [sender: AccountId32, hash_: H256], {
                sender: AccountId32;
                hash_: H256;
            }>;
        };
        technicalCommittee: {
            /**
             * A motion was approved by the required threshold.
             **/
            Approved: AugmentedEvent<ApiType, [proposalHash: H256], {
                proposalHash: H256;
            }>;
            /**
             * A proposal was closed because its threshold was reached or after its duration was up.
             **/
            Closed: AugmentedEvent<ApiType, [proposalHash: H256, yes: u32, no: u32], {
                proposalHash: H256;
                yes: u32;
                no: u32;
            }>;
            /**
             * A motion was not approved by the required threshold.
             **/
            Disapproved: AugmentedEvent<ApiType, [proposalHash: H256], {
                proposalHash: H256;
            }>;
            /**
             * A motion was executed; result will be `Ok` if it returned without error.
             **/
            Executed: AugmentedEvent<ApiType, [proposalHash: H256, result: Result<Null, SpRuntimeDispatchError>], {
                proposalHash: H256;
                result: Result<Null, SpRuntimeDispatchError>;
            }>;
            /**
             * A single member did some action; result will be `Ok` if it returned without error.
             **/
            MemberExecuted: AugmentedEvent<ApiType, [proposalHash: H256, result: Result<Null, SpRuntimeDispatchError>], {
                proposalHash: H256;
                result: Result<Null, SpRuntimeDispatchError>;
            }>;
            /**
             * A motion (given hash) has been proposed (by given account) with a threshold (given
             * `MemberCount`).
             **/
            Proposed: AugmentedEvent<ApiType, [account: AccountId32, proposalIndex: u32, proposalHash: H256, threshold: u32], {
                account: AccountId32;
                proposalIndex: u32;
                proposalHash: H256;
                threshold: u32;
            }>;
            /**
             * A motion (given hash) has been voted on by given account, leaving
             * a tally (yes votes and no votes given respectively as `MemberCount`).
             **/
            Voted: AugmentedEvent<ApiType, [account: AccountId32, proposalHash: H256, voted: bool, yes: u32, no: u32], {
                account: AccountId32;
                proposalHash: H256;
                voted: bool;
                yes: u32;
                no: u32;
            }>;
        };
        technicalCommitteeMembership: {
            /**
             * Phantom member, never used.
             **/
            Dummy: AugmentedEvent<ApiType, []>;
            /**
             * One of the members' keys changed.
             **/
            KeyChanged: AugmentedEvent<ApiType, []>;
            /**
             * The given member was added; see the transaction for who.
             **/
            MemberAdded: AugmentedEvent<ApiType, []>;
            /**
             * The given member was removed; see the transaction for who.
             **/
            MemberRemoved: AugmentedEvent<ApiType, []>;
            /**
             * The membership was reset; see the transaction for who the new set is.
             **/
            MembersReset: AugmentedEvent<ApiType, []>;
            /**
             * Two members were swapped; see the transaction for who.
             **/
            MembersSwapped: AugmentedEvent<ApiType, []>;
        };
        transactionPayment: {
            /**
             * A transaction fee `actual_fee`, of which `tip` was added to the minimum inclusion fee,
             * has been paid by `who`.
             **/
            TransactionFeePaid: AugmentedEvent<ApiType, [who: AccountId32, actualFee: u128, tip: u128], {
                who: AccountId32;
                actualFee: u128;
                tip: u128;
            }>;
        };
        treasury: {
            /**
             * Buyout event
             **/
            Buyout: AugmentedEvent<ApiType, [who: AccountId32, buyoutAmount: u128, asset: u64, exchangeAmount: u128], {
                who: AccountId32;
                buyoutAmount: u128;
                asset: u64;
                exchangeAmount: u128;
            }>;
        };
        utility: {
            /**
             * Batch of dispatches completed fully with no error.
             **/
            BatchCompleted: AugmentedEvent<ApiType, []>;
            /**
             * Batch of dispatches completed but has errors.
             **/
            BatchCompletedWithErrors: AugmentedEvent<ApiType, []>;
            /**
             * Batch of dispatches did not complete fully. Index of first failing dispatch given, as
             * well as the error.
             **/
            BatchInterrupted: AugmentedEvent<ApiType, [index: u32, error: SpRuntimeDispatchError], {
                index: u32;
                error: SpRuntimeDispatchError;
            }>;
            /**
             * A call was dispatched.
             **/
            DispatchedAs: AugmentedEvent<ApiType, [result: Result<Null, SpRuntimeDispatchError>], {
                result: Result<Null, SpRuntimeDispatchError>;
            }>;
            /**
             * A single item within a Batch of dispatches has completed with no error.
             **/
            ItemCompleted: AugmentedEvent<ApiType, []>;
            /**
             * A single item within a Batch of dispatches has completed with error.
             **/
            ItemFailed: AugmentedEvent<ApiType, [error: SpRuntimeDispatchError], {
                error: SpRuntimeDispatchError;
            }>;
        };
        vesting: {
            /**
             * An `account` has become fully vested. No further vesting can happen
             * \[account\]
             **/
            VestingCompleted: AugmentedEvent<ApiType, [AccountId32]>;
            /**
             * The amount vested has been updated. This could indicate more funds are available. The
             * balance given is the amount which is left unvested (and thus locked)
             * \[account, unvested\]
             **/
            VestingUpdated: AugmentedEvent<ApiType, [AccountId32, u128]>;
        };
        vesting2: {
            /**
             * An `account` has become fully vested. No further vesting can happen
             * \[account\]
             **/
            VestingCompleted: AugmentedEvent<ApiType, [AccountId32]>;
            /**
             * The amount vested has been updated. This could indicate more funds are available. The
             * balance given is the amount which is left unvested (and thus locked)
             * \[account, unvested\]
             **/
            VestingUpdated: AugmentedEvent<ApiType, [AccountId32, u128]>;
        };
        whitelists: {
            /**
             * `AccountId` was added to the whitelist. \[who\]
             **/
            AddedToWhitelist: AugmentedEvent<ApiType, [AccountId32]>;
            /**
             * `AccountId` was removed from the whitelist. \[who\]
             **/
            RemovedFromWhitelist: AugmentedEvent<ApiType, [AccountId32]>;
        };
        xcmpQueue: {
            /**
             * Bad XCM format used.
             **/
            BadFormat: AugmentedEvent<ApiType, [messageHash: Option<H256>], {
                messageHash: Option<H256>;
            }>;
            /**
             * Bad XCM version used.
             **/
            BadVersion: AugmentedEvent<ApiType, [messageHash: Option<H256>], {
                messageHash: Option<H256>;
            }>;
            /**
             * Some XCM failed.
             **/
            Fail: AugmentedEvent<ApiType, [messageHash: Option<H256>, error: XcmV2TraitsError, weight: Weight], {
                messageHash: Option<H256>;
                error: XcmV2TraitsError;
                weight: Weight;
            }>;
            /**
             * An XCM exceeded the individual message weight budget.
             **/
            OverweightEnqueued: AugmentedEvent<ApiType, [sender: u32, sentAt: u32, index: u64, required: Weight], {
                sender: u32;
                sentAt: u32;
                index: u64;
                required: Weight;
            }>;
            /**
             * An XCM from the overweight queue was executed with the given actual weight used.
             **/
            OverweightServiced: AugmentedEvent<ApiType, [index: u64, used: Weight], {
                index: u64;
                used: Weight;
            }>;
            /**
             * Some XCM was executed ok.
             **/
            Success: AugmentedEvent<ApiType, [messageHash: Option<H256>, weight: Weight], {
                messageHash: Option<H256>;
                weight: Weight;
            }>;
            /**
             * An upward message was sent to the relay chain.
             **/
            UpwardMessageSent: AugmentedEvent<ApiType, [messageHash: Option<H256>], {
                messageHash: Option<H256>;
            }>;
            /**
             * An HRMP message was sent to a sibling parachain.
             **/
            XcmpMessageSent: AugmentedEvent<ApiType, [messageHash: Option<H256>], {
                messageHash: Option<H256>;
            }>;
        };
        xdot: {
            /**
             * LP tokens was burned, base and xbase was transfered from pool
             *
             * Included values are:
             * - account identifier `T::AccountId`
             * - pool indentifier `PoolId`
             * - base asset amount `T::Balance`
             * - xbase asset amount `T::Balance`
             * - lp tokens amount `T::Balance`
             *
             * \[who, pool_id, base_out, xbase_out, tokens_burned\]
             **/
            Burned: AugmentedEvent<ApiType, [AccountId32, u32, u128, u128, u128]>;
            /**
             * Base was bought from pool in exchange for xbase
             *
             * Included values are:
             * - account identifier `T::AccountId`
             * - pool indentifier `PoolId`
             * - base asset amount `T::Balance`
             * - xbase asset amount `T::Balance`
             **/
            BuyBase: AugmentedEvent<ApiType, [AccountId32, u32, u128, u128]>;
            /**
             * Xbase was bought from pool in exchange for base
             *
             * Included values are:
             * - account identifier `T::AccountId`
             * - pool indentifier `PoolId`
             * - base asset amount `T::Balance`
             * - xbase asset amount `T::Balance`
             **/
            BuyXBase: AugmentedEvent<ApiType, [AccountId32, u32, u128, u128]>;
            /**
             * LP tokens was minted, base and xbase was transfered into pool
             *
             * Included values are:
             * - account identifier `T::AccountId`
             * - pool indentifier `PoolId`
             * - base asset amount `T::Balance`
             * - xbase asset amount `T::Balance`
             * - lp tokens amount `T::Balance`
             *
             * \[who, pool_id, base_in, xbase_in, tokens_minted\]
             **/
            Minted: AugmentedEvent<ApiType, [AccountId32, u32, u128, u128, u128]>;
            /**
             * Pool with specified id `PoolId` was created successfully.
             *
             * Included values are:
             * - pool identifier `PoolId`
             * - LP asset
             * - Base asset
             * - XBase asset
             * - g1 coeff
             * - g2 coeff
             * - ts coeff
             * \[pool_id, base_asset, xbase_asset, g1, g2, ts\]
             **/
            PoolCreated: AugmentedEvent<ApiType, [u32, u64, u64, u64, SubstrateFixedFixedI128, SubstrateFixedFixedI128, SubstrateFixedFixedI128]>;
            /**
             * Base was sold into pool in exchange for xbase.
             *
             * Included values are:
             * - account identifier `T::AccountId`
             * - pool indentifier `PoolId`
             * - base asset amount `T::Balance`
             * - xbase asset amount `T::Balance`
             **/
            SaleBase: AugmentedEvent<ApiType, [AccountId32, u32, u128, u128]>;
            /**
             * Xbase was sold into pool in exchange for base
             *
             * Included values are:
             * - account identifier `T::AccountId`
             * - pool indentifier `PoolId`
             * - base asset amount `T::Balance`
             * - xbase asset amount `T::Balance`
             **/
            SellXBase: AugmentedEvent<ApiType, [AccountId32, u32, u128, u128]>;
        };
    }
}
