import { PoolParams, PoolParamsAmino, PoolParamsSDKType } from "./pool_params";
import { PoolAsset, PoolAssetAmino, PoolAssetSDKType } from "./pool_asset";
import { Coin, CoinAmino, CoinSDKType } from "../../cosmos/base/v1beta1/coin";
import { SwapAmountInRoute, SwapAmountInRouteAmino, SwapAmountInRouteSDKType, SwapAmountOutRoute, SwapAmountOutRouteAmino, SwapAmountOutRouteSDKType } from "./swap_route";
import { Params, ParamsAmino, ParamsSDKType } from "./params";
import { BinaryReader, BinaryWriter } from "../../binary";
import { JsonSafe } from "../../json-safe";
export interface MsgCreatePool {
    sender: string;
    poolParams: PoolParams;
    poolAssets: PoolAsset[];
}
export interface MsgCreatePoolProtoMsg {
    typeUrl: "/elys.amm.MsgCreatePool";
    value: Uint8Array;
}
/**
 * @name MsgCreatePoolAmino
 * @package elys.amm
 * @see proto type: elys.amm.MsgCreatePool
 */
export interface MsgCreatePoolAmino {
    sender?: string;
    pool_params?: PoolParamsAmino;
    pool_assets?: PoolAssetAmino[];
}
export interface MsgCreatePoolAminoMsg {
    type: "amm/MsgCreatePool";
    value: MsgCreatePoolAmino;
}
export interface MsgCreatePoolSDKType {
    sender: string;
    pool_params: PoolParamsSDKType;
    pool_assets: PoolAssetSDKType[];
}
export interface MsgCreatePoolResponse {
    poolId: bigint;
}
export interface MsgCreatePoolResponseProtoMsg {
    typeUrl: "/elys.amm.MsgCreatePoolResponse";
    value: Uint8Array;
}
/**
 * @name MsgCreatePoolResponseAmino
 * @package elys.amm
 * @see proto type: elys.amm.MsgCreatePoolResponse
 */
export interface MsgCreatePoolResponseAmino {
    pool_id?: string;
}
export interface MsgCreatePoolResponseAminoMsg {
    type: "/elys.amm.MsgCreatePoolResponse";
    value: MsgCreatePoolResponseAmino;
}
export interface MsgCreatePoolResponseSDKType {
    pool_id: bigint;
}
export interface MsgJoinPool {
    sender: string;
    poolId: bigint;
    maxAmountsIn: Coin[];
    shareAmountOut: string;
}
export interface MsgJoinPoolProtoMsg {
    typeUrl: "/elys.amm.MsgJoinPool";
    value: Uint8Array;
}
/**
 * @name MsgJoinPoolAmino
 * @package elys.amm
 * @see proto type: elys.amm.MsgJoinPool
 */
export interface MsgJoinPoolAmino {
    sender?: string;
    pool_id?: string;
    max_amounts_in?: CoinAmino[];
    share_amount_out?: string;
}
export interface MsgJoinPoolAminoMsg {
    type: "amm/MsgJoinPool";
    value: MsgJoinPoolAmino;
}
export interface MsgJoinPoolSDKType {
    sender: string;
    pool_id: bigint;
    max_amounts_in: CoinSDKType[];
    share_amount_out: string;
}
export interface MsgJoinPoolResponse {
    shareAmountOut: string;
    tokenIn: Coin[];
}
export interface MsgJoinPoolResponseProtoMsg {
    typeUrl: "/elys.amm.MsgJoinPoolResponse";
    value: Uint8Array;
}
/**
 * @name MsgJoinPoolResponseAmino
 * @package elys.amm
 * @see proto type: elys.amm.MsgJoinPoolResponse
 */
export interface MsgJoinPoolResponseAmino {
    share_amount_out?: string;
    token_in?: CoinAmino[];
}
export interface MsgJoinPoolResponseAminoMsg {
    type: "/elys.amm.MsgJoinPoolResponse";
    value: MsgJoinPoolResponseAmino;
}
export interface MsgJoinPoolResponseSDKType {
    share_amount_out: string;
    token_in: CoinSDKType[];
}
export interface MsgExitPool {
    sender: string;
    poolId: bigint;
    minAmountsOut: Coin[];
    shareAmountIn: string;
    tokenOutDenom: string;
}
export interface MsgExitPoolProtoMsg {
    typeUrl: "/elys.amm.MsgExitPool";
    value: Uint8Array;
}
/**
 * @name MsgExitPoolAmino
 * @package elys.amm
 * @see proto type: elys.amm.MsgExitPool
 */
export interface MsgExitPoolAmino {
    sender?: string;
    pool_id?: string;
    min_amounts_out?: CoinAmino[];
    share_amount_in?: string;
    token_out_denom?: string;
}
export interface MsgExitPoolAminoMsg {
    type: "amm/MsgExitPool";
    value: MsgExitPoolAmino;
}
export interface MsgExitPoolSDKType {
    sender: string;
    pool_id: bigint;
    min_amounts_out: CoinSDKType[];
    share_amount_in: string;
    token_out_denom: string;
}
export interface MsgExitPoolResponse {
    tokenOut: Coin[];
    weightBalanceRatio: string;
    slippage: string;
    swapFee: string;
}
export interface MsgExitPoolResponseProtoMsg {
    typeUrl: "/elys.amm.MsgExitPoolResponse";
    value: Uint8Array;
}
/**
 * @name MsgExitPoolResponseAmino
 * @package elys.amm
 * @see proto type: elys.amm.MsgExitPoolResponse
 */
export interface MsgExitPoolResponseAmino {
    token_out?: CoinAmino[];
    weight_balance_ratio?: string;
    slippage?: string;
    swap_fee?: string;
}
export interface MsgExitPoolResponseAminoMsg {
    type: "/elys.amm.MsgExitPoolResponse";
    value: MsgExitPoolResponseAmino;
}
export interface MsgExitPoolResponseSDKType {
    token_out: CoinSDKType[];
    weight_balance_ratio: string;
    slippage: string;
    swap_fee: string;
}
export interface MsgUpFrontSwapExactAmountIn {
    sender: string;
    routes: SwapAmountInRoute[];
    tokenIn: Coin;
    tokenOutMinAmount: string;
}
export interface MsgUpFrontSwapExactAmountInProtoMsg {
    typeUrl: "/elys.amm.MsgUpFrontSwapExactAmountIn";
    value: Uint8Array;
}
/**
 * @name MsgUpFrontSwapExactAmountInAmino
 * @package elys.amm
 * @see proto type: elys.amm.MsgUpFrontSwapExactAmountIn
 */
export interface MsgUpFrontSwapExactAmountInAmino {
    sender?: string;
    routes?: SwapAmountInRouteAmino[];
    token_in?: CoinAmino;
    token_out_min_amount?: string;
}
export interface MsgUpFrontSwapExactAmountInAminoMsg {
    type: "amm/MsgUpFrontSwapExactAmountIn";
    value: MsgUpFrontSwapExactAmountInAmino;
}
export interface MsgUpFrontSwapExactAmountInSDKType {
    sender: string;
    routes: SwapAmountInRouteSDKType[];
    token_in: CoinSDKType;
    token_out_min_amount: string;
}
export interface MsgUpFrontSwapExactAmountInResponse {
    tokenOutAmount: string;
    swapFee: string;
    discount: string;
}
export interface MsgUpFrontSwapExactAmountInResponseProtoMsg {
    typeUrl: "/elys.amm.MsgUpFrontSwapExactAmountInResponse";
    value: Uint8Array;
}
/**
 * @name MsgUpFrontSwapExactAmountInResponseAmino
 * @package elys.amm
 * @see proto type: elys.amm.MsgUpFrontSwapExactAmountInResponse
 */
export interface MsgUpFrontSwapExactAmountInResponseAmino {
    token_out_amount?: string;
    swap_fee?: string;
    discount?: string;
}
export interface MsgUpFrontSwapExactAmountInResponseAminoMsg {
    type: "/elys.amm.MsgUpFrontSwapExactAmountInResponse";
    value: MsgUpFrontSwapExactAmountInResponseAmino;
}
export interface MsgUpFrontSwapExactAmountInResponseSDKType {
    token_out_amount: string;
    swap_fee: string;
    discount: string;
}
export interface MsgSwapExactAmountIn {
    sender: string;
    routes: SwapAmountInRoute[];
    tokenIn: Coin;
    tokenOutMinAmount: string;
    recipient: string;
}
export interface MsgSwapExactAmountInProtoMsg {
    typeUrl: "/elys.amm.MsgSwapExactAmountIn";
    value: Uint8Array;
}
/**
 * @name MsgSwapExactAmountInAmino
 * @package elys.amm
 * @see proto type: elys.amm.MsgSwapExactAmountIn
 */
export interface MsgSwapExactAmountInAmino {
    sender?: string;
    routes?: SwapAmountInRouteAmino[];
    token_in?: CoinAmino;
    token_out_min_amount?: string;
    recipient?: string;
}
export interface MsgSwapExactAmountInAminoMsg {
    type: "amm/MsgSwapExactAmountIn";
    value: MsgSwapExactAmountInAmino;
}
export interface MsgSwapExactAmountInSDKType {
    sender: string;
    routes: SwapAmountInRouteSDKType[];
    token_in: CoinSDKType;
    token_out_min_amount: string;
    recipient: string;
}
export interface MsgSwapExactAmountInResponse {
    tokenOutAmount: string;
    swapFee: string;
    discount: string;
    recipient: string;
}
export interface MsgSwapExactAmountInResponseProtoMsg {
    typeUrl: "/elys.amm.MsgSwapExactAmountInResponse";
    value: Uint8Array;
}
/**
 * @name MsgSwapExactAmountInResponseAmino
 * @package elys.amm
 * @see proto type: elys.amm.MsgSwapExactAmountInResponse
 */
export interface MsgSwapExactAmountInResponseAmino {
    token_out_amount?: string;
    swap_fee?: string;
    discount?: string;
    recipient?: string;
}
export interface MsgSwapExactAmountInResponseAminoMsg {
    type: "/elys.amm.MsgSwapExactAmountInResponse";
    value: MsgSwapExactAmountInResponseAmino;
}
export interface MsgSwapExactAmountInResponseSDKType {
    token_out_amount: string;
    swap_fee: string;
    discount: string;
    recipient: string;
}
export interface MsgSwapExactAmountOut {
    sender: string;
    routes: SwapAmountOutRoute[];
    tokenOut: Coin;
    tokenInMaxAmount: string;
    recipient: string;
}
export interface MsgSwapExactAmountOutProtoMsg {
    typeUrl: "/elys.amm.MsgSwapExactAmountOut";
    value: Uint8Array;
}
/**
 * @name MsgSwapExactAmountOutAmino
 * @package elys.amm
 * @see proto type: elys.amm.MsgSwapExactAmountOut
 */
export interface MsgSwapExactAmountOutAmino {
    sender?: string;
    routes?: SwapAmountOutRouteAmino[];
    token_out?: CoinAmino;
    token_in_max_amount?: string;
    recipient?: string;
}
export interface MsgSwapExactAmountOutAminoMsg {
    type: "amm/MsgSwapExactAmountOut";
    value: MsgSwapExactAmountOutAmino;
}
export interface MsgSwapExactAmountOutSDKType {
    sender: string;
    routes: SwapAmountOutRouteSDKType[];
    token_out: CoinSDKType;
    token_in_max_amount: string;
    recipient: string;
}
export interface MsgSwapExactAmountOutResponse {
    tokenInAmount: string;
    swapFee: string;
    discount: string;
    recipient: string;
}
export interface MsgSwapExactAmountOutResponseProtoMsg {
    typeUrl: "/elys.amm.MsgSwapExactAmountOutResponse";
    value: Uint8Array;
}
/**
 * @name MsgSwapExactAmountOutResponseAmino
 * @package elys.amm
 * @see proto type: elys.amm.MsgSwapExactAmountOutResponse
 */
export interface MsgSwapExactAmountOutResponseAmino {
    token_in_amount?: string;
    swap_fee?: string;
    discount?: string;
    recipient?: string;
}
export interface MsgSwapExactAmountOutResponseAminoMsg {
    type: "/elys.amm.MsgSwapExactAmountOutResponse";
    value: MsgSwapExactAmountOutResponseAmino;
}
export interface MsgSwapExactAmountOutResponseSDKType {
    token_in_amount: string;
    swap_fee: string;
    discount: string;
    recipient: string;
}
export interface MsgFeedMultipleExternalLiquidity {
    sender: string;
    liquidity: ExternalLiquidity[];
}
export interface MsgFeedMultipleExternalLiquidityProtoMsg {
    typeUrl: "/elys.amm.MsgFeedMultipleExternalLiquidity";
    value: Uint8Array;
}
/**
 * @name MsgFeedMultipleExternalLiquidityAmino
 * @package elys.amm
 * @see proto type: elys.amm.MsgFeedMultipleExternalLiquidity
 */
export interface MsgFeedMultipleExternalLiquidityAmino {
    sender?: string;
    liquidity?: ExternalLiquidityAmino[];
}
export interface MsgFeedMultipleExternalLiquidityAminoMsg {
    type: "amm/MsgFeedMultipleExternalLiquidity";
    value: MsgFeedMultipleExternalLiquidityAmino;
}
export interface MsgFeedMultipleExternalLiquiditySDKType {
    sender: string;
    liquidity: ExternalLiquiditySDKType[];
}
export interface MsgFeedMultipleExternalLiquidityResponse {
}
export interface MsgFeedMultipleExternalLiquidityResponseProtoMsg {
    typeUrl: "/elys.amm.MsgFeedMultipleExternalLiquidityResponse";
    value: Uint8Array;
}
/**
 * @name MsgFeedMultipleExternalLiquidityResponseAmino
 * @package elys.amm
 * @see proto type: elys.amm.MsgFeedMultipleExternalLiquidityResponse
 */
export interface MsgFeedMultipleExternalLiquidityResponseAmino {
}
export interface MsgFeedMultipleExternalLiquidityResponseAminoMsg {
    type: "/elys.amm.MsgFeedMultipleExternalLiquidityResponse";
    value: MsgFeedMultipleExternalLiquidityResponseAmino;
}
export interface MsgFeedMultipleExternalLiquidityResponseSDKType {
}
export interface AssetAmountDepth {
    asset: string;
    amount: string;
    depth: string;
}
export interface AssetAmountDepthProtoMsg {
    typeUrl: "/elys.amm.AssetAmountDepth";
    value: Uint8Array;
}
/**
 * @name AssetAmountDepthAmino
 * @package elys.amm
 * @see proto type: elys.amm.AssetAmountDepth
 */
export interface AssetAmountDepthAmino {
    asset?: string;
    amount?: string;
    depth?: string;
}
export interface AssetAmountDepthAminoMsg {
    type: "/elys.amm.AssetAmountDepth";
    value: AssetAmountDepthAmino;
}
export interface AssetAmountDepthSDKType {
    asset: string;
    amount: string;
    depth: string;
}
/**
 * ExternalLiquidity defines price, volume, and time information for an exchange
 * rate.
 */
export interface ExternalLiquidity {
    poolId: bigint;
    amountDepthInfo: AssetAmountDepth[];
}
export interface ExternalLiquidityProtoMsg {
    typeUrl: "/elys.amm.ExternalLiquidity";
    value: Uint8Array;
}
/**
 * ExternalLiquidity defines price, volume, and time information for an exchange
 * rate.
 * @name ExternalLiquidityAmino
 * @package elys.amm
 * @see proto type: elys.amm.ExternalLiquidity
 */
export interface ExternalLiquidityAmino {
    pool_id?: string;
    amount_depth_info?: AssetAmountDepthAmino[];
}
export interface ExternalLiquidityAminoMsg {
    type: "/elys.amm.ExternalLiquidity";
    value: ExternalLiquidityAmino;
}
/**
 * ExternalLiquidity defines price, volume, and time information for an exchange
 * rate.
 */
export interface ExternalLiquiditySDKType {
    pool_id: bigint;
    amount_depth_info: AssetAmountDepthSDKType[];
}
export interface MsgSwapByDenom {
    sender: string;
    amount: Coin;
    minAmount: Coin;
    maxAmount: Coin;
    denomIn: string;
    denomOut: string;
    recipient: string;
}
export interface MsgSwapByDenomProtoMsg {
    typeUrl: "/elys.amm.MsgSwapByDenom";
    value: Uint8Array;
}
/**
 * @name MsgSwapByDenomAmino
 * @package elys.amm
 * @see proto type: elys.amm.MsgSwapByDenom
 */
export interface MsgSwapByDenomAmino {
    sender?: string;
    amount?: CoinAmino;
    min_amount?: CoinAmino;
    max_amount?: CoinAmino;
    denom_in?: string;
    denom_out?: string;
    recipient?: string;
}
export interface MsgSwapByDenomAminoMsg {
    type: "amm/MsgSwapByDenom";
    value: MsgSwapByDenomAmino;
}
export interface MsgSwapByDenomSDKType {
    sender: string;
    amount: CoinSDKType;
    min_amount: CoinSDKType;
    max_amount: CoinSDKType;
    denom_in: string;
    denom_out: string;
    recipient: string;
}
export interface MsgSwapByDenomResponse {
    amount: Coin;
    inRoute: SwapAmountInRoute[];
    outRoute: SwapAmountOutRoute[];
    spotPrice: string;
    swapFee: string;
    discount: string;
    recipient: string;
    slippage: string;
    weightBonus: string;
}
export interface MsgSwapByDenomResponseProtoMsg {
    typeUrl: "/elys.amm.MsgSwapByDenomResponse";
    value: Uint8Array;
}
/**
 * @name MsgSwapByDenomResponseAmino
 * @package elys.amm
 * @see proto type: elys.amm.MsgSwapByDenomResponse
 */
export interface MsgSwapByDenomResponseAmino {
    amount?: CoinAmino;
    in_route?: SwapAmountInRouteAmino[];
    out_route?: SwapAmountOutRouteAmino[];
    spot_price?: string;
    swap_fee?: string;
    discount?: string;
    recipient?: string;
    slippage?: string;
    weight_bonus?: string;
}
export interface MsgSwapByDenomResponseAminoMsg {
    type: "/elys.amm.MsgSwapByDenomResponse";
    value: MsgSwapByDenomResponseAmino;
}
export interface MsgSwapByDenomResponseSDKType {
    amount: CoinSDKType;
    in_route: SwapAmountInRouteSDKType[];
    out_route: SwapAmountOutRouteSDKType[];
    spot_price: string;
    swap_fee: string;
    discount: string;
    recipient: string;
    slippage: string;
    weight_bonus: string;
}
export interface MsgUpdatePoolParams {
    authority: string;
    poolId: bigint;
    poolParams: PoolParams;
}
export interface MsgUpdatePoolParamsProtoMsg {
    typeUrl: "/elys.amm.MsgUpdatePoolParams";
    value: Uint8Array;
}
/**
 * @name MsgUpdatePoolParamsAmino
 * @package elys.amm
 * @see proto type: elys.amm.MsgUpdatePoolParams
 */
export interface MsgUpdatePoolParamsAmino {
    authority?: string;
    pool_id?: string;
    pool_params?: PoolParamsAmino;
}
export interface MsgUpdatePoolParamsAminoMsg {
    type: "amm/MsgUpdatePoolParams";
    value: MsgUpdatePoolParamsAmino;
}
export interface MsgUpdatePoolParamsSDKType {
    authority: string;
    pool_id: bigint;
    pool_params: PoolParamsSDKType;
}
export interface MsgUpdatePoolParamsResponse {
    poolId: bigint;
    poolParams?: PoolParams;
}
export interface MsgUpdatePoolParamsResponseProtoMsg {
    typeUrl: "/elys.amm.MsgUpdatePoolParamsResponse";
    value: Uint8Array;
}
/**
 * @name MsgUpdatePoolParamsResponseAmino
 * @package elys.amm
 * @see proto type: elys.amm.MsgUpdatePoolParamsResponse
 */
export interface MsgUpdatePoolParamsResponseAmino {
    pool_id?: string;
    pool_params?: PoolParamsAmino;
}
export interface MsgUpdatePoolParamsResponseAminoMsg {
    type: "/elys.amm.MsgUpdatePoolParamsResponse";
    value: MsgUpdatePoolParamsResponseAmino;
}
export interface MsgUpdatePoolParamsResponseSDKType {
    pool_id: bigint;
    pool_params?: PoolParamsSDKType;
}
export interface MsgUpdateParams {
    authority: string;
    params?: Params;
}
export interface MsgUpdateParamsProtoMsg {
    typeUrl: "/elys.amm.MsgUpdateParams";
    value: Uint8Array;
}
/**
 * @name MsgUpdateParamsAmino
 * @package elys.amm
 * @see proto type: elys.amm.MsgUpdateParams
 */
export interface MsgUpdateParamsAmino {
    authority?: string;
    params?: ParamsAmino;
}
export interface MsgUpdateParamsAminoMsg {
    type: "amm/MsgUpdateParams";
    value: MsgUpdateParamsAmino;
}
export interface MsgUpdateParamsSDKType {
    authority: string;
    params?: ParamsSDKType;
}
export interface MsgUpdateParamsResponse {
}
export interface MsgUpdateParamsResponseProtoMsg {
    typeUrl: "/elys.amm.MsgUpdateParamsResponse";
    value: Uint8Array;
}
/**
 * @name MsgUpdateParamsResponseAmino
 * @package elys.amm
 * @see proto type: elys.amm.MsgUpdateParamsResponse
 */
export interface MsgUpdateParamsResponseAmino {
}
export interface MsgUpdateParamsResponseAminoMsg {
    type: "/elys.amm.MsgUpdateParamsResponse";
    value: MsgUpdateParamsResponseAmino;
}
export interface MsgUpdateParamsResponseSDKType {
}
export declare const MsgCreatePool: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is MsgCreatePool;
    isSDK(o: any): o is MsgCreatePoolSDKType;
    isAmino(o: any): o is MsgCreatePoolAmino;
    encode(message: MsgCreatePool, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgCreatePool;
    fromJSON(object: any): MsgCreatePool;
    toJSON(message: MsgCreatePool): JsonSafe<MsgCreatePool>;
    fromPartial(object: Partial<MsgCreatePool>): MsgCreatePool;
    fromAmino(object: MsgCreatePoolAmino): MsgCreatePool;
    toAmino(message: MsgCreatePool): MsgCreatePoolAmino;
    fromAminoMsg(object: MsgCreatePoolAminoMsg): MsgCreatePool;
    toAminoMsg(message: MsgCreatePool): MsgCreatePoolAminoMsg;
    fromProtoMsg(message: MsgCreatePoolProtoMsg): MsgCreatePool;
    toProto(message: MsgCreatePool): Uint8Array;
    toProtoMsg(message: MsgCreatePool): MsgCreatePoolProtoMsg;
};
export declare const MsgCreatePoolResponse: {
    typeUrl: string;
    is(o: any): o is MsgCreatePoolResponse;
    isSDK(o: any): o is MsgCreatePoolResponseSDKType;
    isAmino(o: any): o is MsgCreatePoolResponseAmino;
    encode(message: MsgCreatePoolResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgCreatePoolResponse;
    fromJSON(object: any): MsgCreatePoolResponse;
    toJSON(message: MsgCreatePoolResponse): JsonSafe<MsgCreatePoolResponse>;
    fromPartial(object: Partial<MsgCreatePoolResponse>): MsgCreatePoolResponse;
    fromAmino(object: MsgCreatePoolResponseAmino): MsgCreatePoolResponse;
    toAmino(message: MsgCreatePoolResponse): MsgCreatePoolResponseAmino;
    fromAminoMsg(object: MsgCreatePoolResponseAminoMsg): MsgCreatePoolResponse;
    fromProtoMsg(message: MsgCreatePoolResponseProtoMsg): MsgCreatePoolResponse;
    toProto(message: MsgCreatePoolResponse): Uint8Array;
    toProtoMsg(message: MsgCreatePoolResponse): MsgCreatePoolResponseProtoMsg;
};
export declare const MsgJoinPool: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is MsgJoinPool;
    isSDK(o: any): o is MsgJoinPoolSDKType;
    isAmino(o: any): o is MsgJoinPoolAmino;
    encode(message: MsgJoinPool, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgJoinPool;
    fromJSON(object: any): MsgJoinPool;
    toJSON(message: MsgJoinPool): JsonSafe<MsgJoinPool>;
    fromPartial(object: Partial<MsgJoinPool>): MsgJoinPool;
    fromAmino(object: MsgJoinPoolAmino): MsgJoinPool;
    toAmino(message: MsgJoinPool): MsgJoinPoolAmino;
    fromAminoMsg(object: MsgJoinPoolAminoMsg): MsgJoinPool;
    toAminoMsg(message: MsgJoinPool): MsgJoinPoolAminoMsg;
    fromProtoMsg(message: MsgJoinPoolProtoMsg): MsgJoinPool;
    toProto(message: MsgJoinPool): Uint8Array;
    toProtoMsg(message: MsgJoinPool): MsgJoinPoolProtoMsg;
};
export declare const MsgJoinPoolResponse: {
    typeUrl: string;
    is(o: any): o is MsgJoinPoolResponse;
    isSDK(o: any): o is MsgJoinPoolResponseSDKType;
    isAmino(o: any): o is MsgJoinPoolResponseAmino;
    encode(message: MsgJoinPoolResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgJoinPoolResponse;
    fromJSON(object: any): MsgJoinPoolResponse;
    toJSON(message: MsgJoinPoolResponse): JsonSafe<MsgJoinPoolResponse>;
    fromPartial(object: Partial<MsgJoinPoolResponse>): MsgJoinPoolResponse;
    fromAmino(object: MsgJoinPoolResponseAmino): MsgJoinPoolResponse;
    toAmino(message: MsgJoinPoolResponse): MsgJoinPoolResponseAmino;
    fromAminoMsg(object: MsgJoinPoolResponseAminoMsg): MsgJoinPoolResponse;
    fromProtoMsg(message: MsgJoinPoolResponseProtoMsg): MsgJoinPoolResponse;
    toProto(message: MsgJoinPoolResponse): Uint8Array;
    toProtoMsg(message: MsgJoinPoolResponse): MsgJoinPoolResponseProtoMsg;
};
export declare const MsgExitPool: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is MsgExitPool;
    isSDK(o: any): o is MsgExitPoolSDKType;
    isAmino(o: any): o is MsgExitPoolAmino;
    encode(message: MsgExitPool, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgExitPool;
    fromJSON(object: any): MsgExitPool;
    toJSON(message: MsgExitPool): JsonSafe<MsgExitPool>;
    fromPartial(object: Partial<MsgExitPool>): MsgExitPool;
    fromAmino(object: MsgExitPoolAmino): MsgExitPool;
    toAmino(message: MsgExitPool): MsgExitPoolAmino;
    fromAminoMsg(object: MsgExitPoolAminoMsg): MsgExitPool;
    toAminoMsg(message: MsgExitPool): MsgExitPoolAminoMsg;
    fromProtoMsg(message: MsgExitPoolProtoMsg): MsgExitPool;
    toProto(message: MsgExitPool): Uint8Array;
    toProtoMsg(message: MsgExitPool): MsgExitPoolProtoMsg;
};
export declare const MsgExitPoolResponse: {
    typeUrl: string;
    is(o: any): o is MsgExitPoolResponse;
    isSDK(o: any): o is MsgExitPoolResponseSDKType;
    isAmino(o: any): o is MsgExitPoolResponseAmino;
    encode(message: MsgExitPoolResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgExitPoolResponse;
    fromJSON(object: any): MsgExitPoolResponse;
    toJSON(message: MsgExitPoolResponse): JsonSafe<MsgExitPoolResponse>;
    fromPartial(object: Partial<MsgExitPoolResponse>): MsgExitPoolResponse;
    fromAmino(object: MsgExitPoolResponseAmino): MsgExitPoolResponse;
    toAmino(message: MsgExitPoolResponse): MsgExitPoolResponseAmino;
    fromAminoMsg(object: MsgExitPoolResponseAminoMsg): MsgExitPoolResponse;
    fromProtoMsg(message: MsgExitPoolResponseProtoMsg): MsgExitPoolResponse;
    toProto(message: MsgExitPoolResponse): Uint8Array;
    toProtoMsg(message: MsgExitPoolResponse): MsgExitPoolResponseProtoMsg;
};
export declare const MsgUpFrontSwapExactAmountIn: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is MsgUpFrontSwapExactAmountIn;
    isSDK(o: any): o is MsgUpFrontSwapExactAmountInSDKType;
    isAmino(o: any): o is MsgUpFrontSwapExactAmountInAmino;
    encode(message: MsgUpFrontSwapExactAmountIn, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgUpFrontSwapExactAmountIn;
    fromJSON(object: any): MsgUpFrontSwapExactAmountIn;
    toJSON(message: MsgUpFrontSwapExactAmountIn): JsonSafe<MsgUpFrontSwapExactAmountIn>;
    fromPartial(object: Partial<MsgUpFrontSwapExactAmountIn>): MsgUpFrontSwapExactAmountIn;
    fromAmino(object: MsgUpFrontSwapExactAmountInAmino): MsgUpFrontSwapExactAmountIn;
    toAmino(message: MsgUpFrontSwapExactAmountIn): MsgUpFrontSwapExactAmountInAmino;
    fromAminoMsg(object: MsgUpFrontSwapExactAmountInAminoMsg): MsgUpFrontSwapExactAmountIn;
    toAminoMsg(message: MsgUpFrontSwapExactAmountIn): MsgUpFrontSwapExactAmountInAminoMsg;
    fromProtoMsg(message: MsgUpFrontSwapExactAmountInProtoMsg): MsgUpFrontSwapExactAmountIn;
    toProto(message: MsgUpFrontSwapExactAmountIn): Uint8Array;
    toProtoMsg(message: MsgUpFrontSwapExactAmountIn): MsgUpFrontSwapExactAmountInProtoMsg;
};
export declare const MsgUpFrontSwapExactAmountInResponse: {
    typeUrl: string;
    is(o: any): o is MsgUpFrontSwapExactAmountInResponse;
    isSDK(o: any): o is MsgUpFrontSwapExactAmountInResponseSDKType;
    isAmino(o: any): o is MsgUpFrontSwapExactAmountInResponseAmino;
    encode(message: MsgUpFrontSwapExactAmountInResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgUpFrontSwapExactAmountInResponse;
    fromJSON(object: any): MsgUpFrontSwapExactAmountInResponse;
    toJSON(message: MsgUpFrontSwapExactAmountInResponse): JsonSafe<MsgUpFrontSwapExactAmountInResponse>;
    fromPartial(object: Partial<MsgUpFrontSwapExactAmountInResponse>): MsgUpFrontSwapExactAmountInResponse;
    fromAmino(object: MsgUpFrontSwapExactAmountInResponseAmino): MsgUpFrontSwapExactAmountInResponse;
    toAmino(message: MsgUpFrontSwapExactAmountInResponse): MsgUpFrontSwapExactAmountInResponseAmino;
    fromAminoMsg(object: MsgUpFrontSwapExactAmountInResponseAminoMsg): MsgUpFrontSwapExactAmountInResponse;
    fromProtoMsg(message: MsgUpFrontSwapExactAmountInResponseProtoMsg): MsgUpFrontSwapExactAmountInResponse;
    toProto(message: MsgUpFrontSwapExactAmountInResponse): Uint8Array;
    toProtoMsg(message: MsgUpFrontSwapExactAmountInResponse): MsgUpFrontSwapExactAmountInResponseProtoMsg;
};
export declare const MsgSwapExactAmountIn: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is MsgSwapExactAmountIn;
    isSDK(o: any): o is MsgSwapExactAmountInSDKType;
    isAmino(o: any): o is MsgSwapExactAmountInAmino;
    encode(message: MsgSwapExactAmountIn, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgSwapExactAmountIn;
    fromJSON(object: any): MsgSwapExactAmountIn;
    toJSON(message: MsgSwapExactAmountIn): JsonSafe<MsgSwapExactAmountIn>;
    fromPartial(object: Partial<MsgSwapExactAmountIn>): MsgSwapExactAmountIn;
    fromAmino(object: MsgSwapExactAmountInAmino): MsgSwapExactAmountIn;
    toAmino(message: MsgSwapExactAmountIn): MsgSwapExactAmountInAmino;
    fromAminoMsg(object: MsgSwapExactAmountInAminoMsg): MsgSwapExactAmountIn;
    toAminoMsg(message: MsgSwapExactAmountIn): MsgSwapExactAmountInAminoMsg;
    fromProtoMsg(message: MsgSwapExactAmountInProtoMsg): MsgSwapExactAmountIn;
    toProto(message: MsgSwapExactAmountIn): Uint8Array;
    toProtoMsg(message: MsgSwapExactAmountIn): MsgSwapExactAmountInProtoMsg;
};
export declare const MsgSwapExactAmountInResponse: {
    typeUrl: string;
    is(o: any): o is MsgSwapExactAmountInResponse;
    isSDK(o: any): o is MsgSwapExactAmountInResponseSDKType;
    isAmino(o: any): o is MsgSwapExactAmountInResponseAmino;
    encode(message: MsgSwapExactAmountInResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgSwapExactAmountInResponse;
    fromJSON(object: any): MsgSwapExactAmountInResponse;
    toJSON(message: MsgSwapExactAmountInResponse): JsonSafe<MsgSwapExactAmountInResponse>;
    fromPartial(object: Partial<MsgSwapExactAmountInResponse>): MsgSwapExactAmountInResponse;
    fromAmino(object: MsgSwapExactAmountInResponseAmino): MsgSwapExactAmountInResponse;
    toAmino(message: MsgSwapExactAmountInResponse): MsgSwapExactAmountInResponseAmino;
    fromAminoMsg(object: MsgSwapExactAmountInResponseAminoMsg): MsgSwapExactAmountInResponse;
    fromProtoMsg(message: MsgSwapExactAmountInResponseProtoMsg): MsgSwapExactAmountInResponse;
    toProto(message: MsgSwapExactAmountInResponse): Uint8Array;
    toProtoMsg(message: MsgSwapExactAmountInResponse): MsgSwapExactAmountInResponseProtoMsg;
};
export declare const MsgSwapExactAmountOut: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is MsgSwapExactAmountOut;
    isSDK(o: any): o is MsgSwapExactAmountOutSDKType;
    isAmino(o: any): o is MsgSwapExactAmountOutAmino;
    encode(message: MsgSwapExactAmountOut, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgSwapExactAmountOut;
    fromJSON(object: any): MsgSwapExactAmountOut;
    toJSON(message: MsgSwapExactAmountOut): JsonSafe<MsgSwapExactAmountOut>;
    fromPartial(object: Partial<MsgSwapExactAmountOut>): MsgSwapExactAmountOut;
    fromAmino(object: MsgSwapExactAmountOutAmino): MsgSwapExactAmountOut;
    toAmino(message: MsgSwapExactAmountOut): MsgSwapExactAmountOutAmino;
    fromAminoMsg(object: MsgSwapExactAmountOutAminoMsg): MsgSwapExactAmountOut;
    toAminoMsg(message: MsgSwapExactAmountOut): MsgSwapExactAmountOutAminoMsg;
    fromProtoMsg(message: MsgSwapExactAmountOutProtoMsg): MsgSwapExactAmountOut;
    toProto(message: MsgSwapExactAmountOut): Uint8Array;
    toProtoMsg(message: MsgSwapExactAmountOut): MsgSwapExactAmountOutProtoMsg;
};
export declare const MsgSwapExactAmountOutResponse: {
    typeUrl: string;
    is(o: any): o is MsgSwapExactAmountOutResponse;
    isSDK(o: any): o is MsgSwapExactAmountOutResponseSDKType;
    isAmino(o: any): o is MsgSwapExactAmountOutResponseAmino;
    encode(message: MsgSwapExactAmountOutResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgSwapExactAmountOutResponse;
    fromJSON(object: any): MsgSwapExactAmountOutResponse;
    toJSON(message: MsgSwapExactAmountOutResponse): JsonSafe<MsgSwapExactAmountOutResponse>;
    fromPartial(object: Partial<MsgSwapExactAmountOutResponse>): MsgSwapExactAmountOutResponse;
    fromAmino(object: MsgSwapExactAmountOutResponseAmino): MsgSwapExactAmountOutResponse;
    toAmino(message: MsgSwapExactAmountOutResponse): MsgSwapExactAmountOutResponseAmino;
    fromAminoMsg(object: MsgSwapExactAmountOutResponseAminoMsg): MsgSwapExactAmountOutResponse;
    fromProtoMsg(message: MsgSwapExactAmountOutResponseProtoMsg): MsgSwapExactAmountOutResponse;
    toProto(message: MsgSwapExactAmountOutResponse): Uint8Array;
    toProtoMsg(message: MsgSwapExactAmountOutResponse): MsgSwapExactAmountOutResponseProtoMsg;
};
export declare const MsgFeedMultipleExternalLiquidity: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is MsgFeedMultipleExternalLiquidity;
    isSDK(o: any): o is MsgFeedMultipleExternalLiquiditySDKType;
    isAmino(o: any): o is MsgFeedMultipleExternalLiquidityAmino;
    encode(message: MsgFeedMultipleExternalLiquidity, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgFeedMultipleExternalLiquidity;
    fromJSON(object: any): MsgFeedMultipleExternalLiquidity;
    toJSON(message: MsgFeedMultipleExternalLiquidity): JsonSafe<MsgFeedMultipleExternalLiquidity>;
    fromPartial(object: Partial<MsgFeedMultipleExternalLiquidity>): MsgFeedMultipleExternalLiquidity;
    fromAmino(object: MsgFeedMultipleExternalLiquidityAmino): MsgFeedMultipleExternalLiquidity;
    toAmino(message: MsgFeedMultipleExternalLiquidity): MsgFeedMultipleExternalLiquidityAmino;
    fromAminoMsg(object: MsgFeedMultipleExternalLiquidityAminoMsg): MsgFeedMultipleExternalLiquidity;
    toAminoMsg(message: MsgFeedMultipleExternalLiquidity): MsgFeedMultipleExternalLiquidityAminoMsg;
    fromProtoMsg(message: MsgFeedMultipleExternalLiquidityProtoMsg): MsgFeedMultipleExternalLiquidity;
    toProto(message: MsgFeedMultipleExternalLiquidity): Uint8Array;
    toProtoMsg(message: MsgFeedMultipleExternalLiquidity): MsgFeedMultipleExternalLiquidityProtoMsg;
};
export declare const MsgFeedMultipleExternalLiquidityResponse: {
    typeUrl: string;
    is(o: any): o is MsgFeedMultipleExternalLiquidityResponse;
    isSDK(o: any): o is MsgFeedMultipleExternalLiquidityResponseSDKType;
    isAmino(o: any): o is MsgFeedMultipleExternalLiquidityResponseAmino;
    encode(_: MsgFeedMultipleExternalLiquidityResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgFeedMultipleExternalLiquidityResponse;
    fromJSON(_: any): MsgFeedMultipleExternalLiquidityResponse;
    toJSON(_: MsgFeedMultipleExternalLiquidityResponse): JsonSafe<MsgFeedMultipleExternalLiquidityResponse>;
    fromPartial(_: Partial<MsgFeedMultipleExternalLiquidityResponse>): MsgFeedMultipleExternalLiquidityResponse;
    fromAmino(_: MsgFeedMultipleExternalLiquidityResponseAmino): MsgFeedMultipleExternalLiquidityResponse;
    toAmino(_: MsgFeedMultipleExternalLiquidityResponse): MsgFeedMultipleExternalLiquidityResponseAmino;
    fromAminoMsg(object: MsgFeedMultipleExternalLiquidityResponseAminoMsg): MsgFeedMultipleExternalLiquidityResponse;
    fromProtoMsg(message: MsgFeedMultipleExternalLiquidityResponseProtoMsg): MsgFeedMultipleExternalLiquidityResponse;
    toProto(message: MsgFeedMultipleExternalLiquidityResponse): Uint8Array;
    toProtoMsg(message: MsgFeedMultipleExternalLiquidityResponse): MsgFeedMultipleExternalLiquidityResponseProtoMsg;
};
export declare const AssetAmountDepth: {
    typeUrl: string;
    is(o: any): o is AssetAmountDepth;
    isSDK(o: any): o is AssetAmountDepthSDKType;
    isAmino(o: any): o is AssetAmountDepthAmino;
    encode(message: AssetAmountDepth, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): AssetAmountDepth;
    fromJSON(object: any): AssetAmountDepth;
    toJSON(message: AssetAmountDepth): JsonSafe<AssetAmountDepth>;
    fromPartial(object: Partial<AssetAmountDepth>): AssetAmountDepth;
    fromAmino(object: AssetAmountDepthAmino): AssetAmountDepth;
    toAmino(message: AssetAmountDepth): AssetAmountDepthAmino;
    fromAminoMsg(object: AssetAmountDepthAminoMsg): AssetAmountDepth;
    fromProtoMsg(message: AssetAmountDepthProtoMsg): AssetAmountDepth;
    toProto(message: AssetAmountDepth): Uint8Array;
    toProtoMsg(message: AssetAmountDepth): AssetAmountDepthProtoMsg;
};
export declare const ExternalLiquidity: {
    typeUrl: string;
    is(o: any): o is ExternalLiquidity;
    isSDK(o: any): o is ExternalLiquiditySDKType;
    isAmino(o: any): o is ExternalLiquidityAmino;
    encode(message: ExternalLiquidity, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ExternalLiquidity;
    fromJSON(object: any): ExternalLiquidity;
    toJSON(message: ExternalLiquidity): JsonSafe<ExternalLiquidity>;
    fromPartial(object: Partial<ExternalLiquidity>): ExternalLiquidity;
    fromAmino(object: ExternalLiquidityAmino): ExternalLiquidity;
    toAmino(message: ExternalLiquidity): ExternalLiquidityAmino;
    fromAminoMsg(object: ExternalLiquidityAminoMsg): ExternalLiquidity;
    fromProtoMsg(message: ExternalLiquidityProtoMsg): ExternalLiquidity;
    toProto(message: ExternalLiquidity): Uint8Array;
    toProtoMsg(message: ExternalLiquidity): ExternalLiquidityProtoMsg;
};
export declare const MsgSwapByDenom: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is MsgSwapByDenom;
    isSDK(o: any): o is MsgSwapByDenomSDKType;
    isAmino(o: any): o is MsgSwapByDenomAmino;
    encode(message: MsgSwapByDenom, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgSwapByDenom;
    fromJSON(object: any): MsgSwapByDenom;
    toJSON(message: MsgSwapByDenom): JsonSafe<MsgSwapByDenom>;
    fromPartial(object: Partial<MsgSwapByDenom>): MsgSwapByDenom;
    fromAmino(object: MsgSwapByDenomAmino): MsgSwapByDenom;
    toAmino(message: MsgSwapByDenom): MsgSwapByDenomAmino;
    fromAminoMsg(object: MsgSwapByDenomAminoMsg): MsgSwapByDenom;
    toAminoMsg(message: MsgSwapByDenom): MsgSwapByDenomAminoMsg;
    fromProtoMsg(message: MsgSwapByDenomProtoMsg): MsgSwapByDenom;
    toProto(message: MsgSwapByDenom): Uint8Array;
    toProtoMsg(message: MsgSwapByDenom): MsgSwapByDenomProtoMsg;
};
export declare const MsgSwapByDenomResponse: {
    typeUrl: string;
    is(o: any): o is MsgSwapByDenomResponse;
    isSDK(o: any): o is MsgSwapByDenomResponseSDKType;
    isAmino(o: any): o is MsgSwapByDenomResponseAmino;
    encode(message: MsgSwapByDenomResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgSwapByDenomResponse;
    fromJSON(object: any): MsgSwapByDenomResponse;
    toJSON(message: MsgSwapByDenomResponse): JsonSafe<MsgSwapByDenomResponse>;
    fromPartial(object: Partial<MsgSwapByDenomResponse>): MsgSwapByDenomResponse;
    fromAmino(object: MsgSwapByDenomResponseAmino): MsgSwapByDenomResponse;
    toAmino(message: MsgSwapByDenomResponse): MsgSwapByDenomResponseAmino;
    fromAminoMsg(object: MsgSwapByDenomResponseAminoMsg): MsgSwapByDenomResponse;
    fromProtoMsg(message: MsgSwapByDenomResponseProtoMsg): MsgSwapByDenomResponse;
    toProto(message: MsgSwapByDenomResponse): Uint8Array;
    toProtoMsg(message: MsgSwapByDenomResponse): MsgSwapByDenomResponseProtoMsg;
};
export declare const MsgUpdatePoolParams: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is MsgUpdatePoolParams;
    isSDK(o: any): o is MsgUpdatePoolParamsSDKType;
    isAmino(o: any): o is MsgUpdatePoolParamsAmino;
    encode(message: MsgUpdatePoolParams, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgUpdatePoolParams;
    fromJSON(object: any): MsgUpdatePoolParams;
    toJSON(message: MsgUpdatePoolParams): JsonSafe<MsgUpdatePoolParams>;
    fromPartial(object: Partial<MsgUpdatePoolParams>): MsgUpdatePoolParams;
    fromAmino(object: MsgUpdatePoolParamsAmino): MsgUpdatePoolParams;
    toAmino(message: MsgUpdatePoolParams): MsgUpdatePoolParamsAmino;
    fromAminoMsg(object: MsgUpdatePoolParamsAminoMsg): MsgUpdatePoolParams;
    toAminoMsg(message: MsgUpdatePoolParams): MsgUpdatePoolParamsAminoMsg;
    fromProtoMsg(message: MsgUpdatePoolParamsProtoMsg): MsgUpdatePoolParams;
    toProto(message: MsgUpdatePoolParams): Uint8Array;
    toProtoMsg(message: MsgUpdatePoolParams): MsgUpdatePoolParamsProtoMsg;
};
export declare const MsgUpdatePoolParamsResponse: {
    typeUrl: string;
    is(o: any): o is MsgUpdatePoolParamsResponse;
    isSDK(o: any): o is MsgUpdatePoolParamsResponseSDKType;
    isAmino(o: any): o is MsgUpdatePoolParamsResponseAmino;
    encode(message: MsgUpdatePoolParamsResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgUpdatePoolParamsResponse;
    fromJSON(object: any): MsgUpdatePoolParamsResponse;
    toJSON(message: MsgUpdatePoolParamsResponse): JsonSafe<MsgUpdatePoolParamsResponse>;
    fromPartial(object: Partial<MsgUpdatePoolParamsResponse>): MsgUpdatePoolParamsResponse;
    fromAmino(object: MsgUpdatePoolParamsResponseAmino): MsgUpdatePoolParamsResponse;
    toAmino(message: MsgUpdatePoolParamsResponse): MsgUpdatePoolParamsResponseAmino;
    fromAminoMsg(object: MsgUpdatePoolParamsResponseAminoMsg): MsgUpdatePoolParamsResponse;
    fromProtoMsg(message: MsgUpdatePoolParamsResponseProtoMsg): MsgUpdatePoolParamsResponse;
    toProto(message: MsgUpdatePoolParamsResponse): Uint8Array;
    toProtoMsg(message: MsgUpdatePoolParamsResponse): MsgUpdatePoolParamsResponseProtoMsg;
};
export declare const MsgUpdateParams: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is MsgUpdateParams;
    isSDK(o: any): o is MsgUpdateParamsSDKType;
    isAmino(o: any): o is MsgUpdateParamsAmino;
    encode(message: MsgUpdateParams, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgUpdateParams;
    fromJSON(object: any): MsgUpdateParams;
    toJSON(message: MsgUpdateParams): JsonSafe<MsgUpdateParams>;
    fromPartial(object: Partial<MsgUpdateParams>): MsgUpdateParams;
    fromAmino(object: MsgUpdateParamsAmino): MsgUpdateParams;
    toAmino(message: MsgUpdateParams): MsgUpdateParamsAmino;
    fromAminoMsg(object: MsgUpdateParamsAminoMsg): MsgUpdateParams;
    toAminoMsg(message: MsgUpdateParams): MsgUpdateParamsAminoMsg;
    fromProtoMsg(message: MsgUpdateParamsProtoMsg): MsgUpdateParams;
    toProto(message: MsgUpdateParams): Uint8Array;
    toProtoMsg(message: MsgUpdateParams): MsgUpdateParamsProtoMsg;
};
export declare const MsgUpdateParamsResponse: {
    typeUrl: string;
    is(o: any): o is MsgUpdateParamsResponse;
    isSDK(o: any): o is MsgUpdateParamsResponseSDKType;
    isAmino(o: any): o is MsgUpdateParamsResponseAmino;
    encode(_: MsgUpdateParamsResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgUpdateParamsResponse;
    fromJSON(_: any): MsgUpdateParamsResponse;
    toJSON(_: MsgUpdateParamsResponse): JsonSafe<MsgUpdateParamsResponse>;
    fromPartial(_: Partial<MsgUpdateParamsResponse>): MsgUpdateParamsResponse;
    fromAmino(_: MsgUpdateParamsResponseAmino): MsgUpdateParamsResponse;
    toAmino(_: MsgUpdateParamsResponse): MsgUpdateParamsResponseAmino;
    fromAminoMsg(object: MsgUpdateParamsResponseAminoMsg): MsgUpdateParamsResponse;
    fromProtoMsg(message: MsgUpdateParamsResponseProtoMsg): MsgUpdateParamsResponse;
    toProto(message: MsgUpdateParamsResponse): Uint8Array;
    toProtoMsg(message: MsgUpdateParamsResponse): MsgUpdateParamsResponseProtoMsg;
};