// package: provenance.exchange.v1
// file: provenance/exchange/v1/tx.proto

/* tslint:disable */
/* eslint-disable */

import * as jspb from "google-protobuf";
import * as cosmos_base_v1beta1_coin_pb from "../../../cosmos/base/v1beta1/coin_pb";
import * as cosmos_msg_v1_msg_pb from "../../../cosmos/msg/v1/msg_pb";
import * as cosmos_proto_cosmos_pb from "../../../cosmos_proto/cosmos_pb";
import * as gogoproto_gogo_pb from "../../../gogoproto/gogo_pb";
import * as provenance_exchange_v1_commitments_pb from "../../../provenance/exchange/v1/commitments_pb";
import * as provenance_exchange_v1_market_pb from "../../../provenance/exchange/v1/market_pb";
import * as provenance_exchange_v1_orders_pb from "../../../provenance/exchange/v1/orders_pb";
import * as provenance_exchange_v1_params_pb from "../../../provenance/exchange/v1/params_pb";
import * as provenance_exchange_v1_payments_pb from "../../../provenance/exchange/v1/payments_pb";

export class MsgCreateAskRequest extends jspb.Message { 

    hasAskOrder(): boolean;
    clearAskOrder(): void;
    getAskOrder(): provenance_exchange_v1_orders_pb.AskOrder | undefined;
    setAskOrder(value?: provenance_exchange_v1_orders_pb.AskOrder): MsgCreateAskRequest;

    hasOrderCreationFee(): boolean;
    clearOrderCreationFee(): void;
    getOrderCreationFee(): cosmos_base_v1beta1_coin_pb.Coin | undefined;
    setOrderCreationFee(value?: cosmos_base_v1beta1_coin_pb.Coin): MsgCreateAskRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgCreateAskRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgCreateAskRequest): MsgCreateAskRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgCreateAskRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgCreateAskRequest;
    static deserializeBinaryFromReader(message: MsgCreateAskRequest, reader: jspb.BinaryReader): MsgCreateAskRequest;
}

export namespace MsgCreateAskRequest {
    export type AsObject = {
        askOrder?: provenance_exchange_v1_orders_pb.AskOrder.AsObject,
        orderCreationFee?: cosmos_base_v1beta1_coin_pb.Coin.AsObject,
    }
}

export class MsgCreateAskResponse extends jspb.Message { 
    getOrderId(): number;
    setOrderId(value: number): MsgCreateAskResponse;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgCreateAskResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgCreateAskResponse): MsgCreateAskResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgCreateAskResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgCreateAskResponse;
    static deserializeBinaryFromReader(message: MsgCreateAskResponse, reader: jspb.BinaryReader): MsgCreateAskResponse;
}

export namespace MsgCreateAskResponse {
    export type AsObject = {
        orderId: number,
    }
}

export class MsgCreateBidRequest extends jspb.Message { 

    hasBidOrder(): boolean;
    clearBidOrder(): void;
    getBidOrder(): provenance_exchange_v1_orders_pb.BidOrder | undefined;
    setBidOrder(value?: provenance_exchange_v1_orders_pb.BidOrder): MsgCreateBidRequest;

    hasOrderCreationFee(): boolean;
    clearOrderCreationFee(): void;
    getOrderCreationFee(): cosmos_base_v1beta1_coin_pb.Coin | undefined;
    setOrderCreationFee(value?: cosmos_base_v1beta1_coin_pb.Coin): MsgCreateBidRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgCreateBidRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgCreateBidRequest): MsgCreateBidRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgCreateBidRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgCreateBidRequest;
    static deserializeBinaryFromReader(message: MsgCreateBidRequest, reader: jspb.BinaryReader): MsgCreateBidRequest;
}

export namespace MsgCreateBidRequest {
    export type AsObject = {
        bidOrder?: provenance_exchange_v1_orders_pb.BidOrder.AsObject,
        orderCreationFee?: cosmos_base_v1beta1_coin_pb.Coin.AsObject,
    }
}

export class MsgCreateBidResponse extends jspb.Message { 
    getOrderId(): number;
    setOrderId(value: number): MsgCreateBidResponse;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgCreateBidResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgCreateBidResponse): MsgCreateBidResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgCreateBidResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgCreateBidResponse;
    static deserializeBinaryFromReader(message: MsgCreateBidResponse, reader: jspb.BinaryReader): MsgCreateBidResponse;
}

export namespace MsgCreateBidResponse {
    export type AsObject = {
        orderId: number,
    }
}

export class MsgCommitFundsRequest extends jspb.Message { 
    getAccount(): string;
    setAccount(value: string): MsgCommitFundsRequest;
    getMarketId(): number;
    setMarketId(value: number): MsgCommitFundsRequest;
    clearAmountList(): void;
    getAmountList(): Array<cosmos_base_v1beta1_coin_pb.Coin>;
    setAmountList(value: Array<cosmos_base_v1beta1_coin_pb.Coin>): MsgCommitFundsRequest;
    addAmount(value?: cosmos_base_v1beta1_coin_pb.Coin, index?: number): cosmos_base_v1beta1_coin_pb.Coin;

    hasCreationFee(): boolean;
    clearCreationFee(): void;
    getCreationFee(): cosmos_base_v1beta1_coin_pb.Coin | undefined;
    setCreationFee(value?: cosmos_base_v1beta1_coin_pb.Coin): MsgCommitFundsRequest;
    getEventTag(): string;
    setEventTag(value: string): MsgCommitFundsRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgCommitFundsRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgCommitFundsRequest): MsgCommitFundsRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgCommitFundsRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgCommitFundsRequest;
    static deserializeBinaryFromReader(message: MsgCommitFundsRequest, reader: jspb.BinaryReader): MsgCommitFundsRequest;
}

export namespace MsgCommitFundsRequest {
    export type AsObject = {
        account: string,
        marketId: number,
        amountList: Array<cosmos_base_v1beta1_coin_pb.Coin.AsObject>,
        creationFee?: cosmos_base_v1beta1_coin_pb.Coin.AsObject,
        eventTag: string,
    }
}

export class MsgCommitFundsResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgCommitFundsResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgCommitFundsResponse): MsgCommitFundsResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgCommitFundsResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgCommitFundsResponse;
    static deserializeBinaryFromReader(message: MsgCommitFundsResponse, reader: jspb.BinaryReader): MsgCommitFundsResponse;
}

export namespace MsgCommitFundsResponse {
    export type AsObject = {
    }
}

export class MsgCancelOrderRequest extends jspb.Message { 
    getSigner(): string;
    setSigner(value: string): MsgCancelOrderRequest;
    getOrderId(): number;
    setOrderId(value: number): MsgCancelOrderRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgCancelOrderRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgCancelOrderRequest): MsgCancelOrderRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgCancelOrderRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgCancelOrderRequest;
    static deserializeBinaryFromReader(message: MsgCancelOrderRequest, reader: jspb.BinaryReader): MsgCancelOrderRequest;
}

export namespace MsgCancelOrderRequest {
    export type AsObject = {
        signer: string,
        orderId: number,
    }
}

export class MsgCancelOrderResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgCancelOrderResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgCancelOrderResponse): MsgCancelOrderResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgCancelOrderResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgCancelOrderResponse;
    static deserializeBinaryFromReader(message: MsgCancelOrderResponse, reader: jspb.BinaryReader): MsgCancelOrderResponse;
}

export namespace MsgCancelOrderResponse {
    export type AsObject = {
    }
}

export class MsgFillBidsRequest extends jspb.Message { 
    getSeller(): string;
    setSeller(value: string): MsgFillBidsRequest;
    getMarketId(): number;
    setMarketId(value: number): MsgFillBidsRequest;
    clearTotalAssetsList(): void;
    getTotalAssetsList(): Array<cosmos_base_v1beta1_coin_pb.Coin>;
    setTotalAssetsList(value: Array<cosmos_base_v1beta1_coin_pb.Coin>): MsgFillBidsRequest;
    addTotalAssets(value?: cosmos_base_v1beta1_coin_pb.Coin, index?: number): cosmos_base_v1beta1_coin_pb.Coin;
    clearBidOrderIdsList(): void;
    getBidOrderIdsList(): Array<number>;
    setBidOrderIdsList(value: Array<number>): MsgFillBidsRequest;
    addBidOrderIds(value: number, index?: number): number;

    hasSellerSettlementFlatFee(): boolean;
    clearSellerSettlementFlatFee(): void;
    getSellerSettlementFlatFee(): cosmos_base_v1beta1_coin_pb.Coin | undefined;
    setSellerSettlementFlatFee(value?: cosmos_base_v1beta1_coin_pb.Coin): MsgFillBidsRequest;

    hasAskOrderCreationFee(): boolean;
    clearAskOrderCreationFee(): void;
    getAskOrderCreationFee(): cosmos_base_v1beta1_coin_pb.Coin | undefined;
    setAskOrderCreationFee(value?: cosmos_base_v1beta1_coin_pb.Coin): MsgFillBidsRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgFillBidsRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgFillBidsRequest): MsgFillBidsRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgFillBidsRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgFillBidsRequest;
    static deserializeBinaryFromReader(message: MsgFillBidsRequest, reader: jspb.BinaryReader): MsgFillBidsRequest;
}

export namespace MsgFillBidsRequest {
    export type AsObject = {
        seller: string,
        marketId: number,
        totalAssetsList: Array<cosmos_base_v1beta1_coin_pb.Coin.AsObject>,
        bidOrderIdsList: Array<number>,
        sellerSettlementFlatFee?: cosmos_base_v1beta1_coin_pb.Coin.AsObject,
        askOrderCreationFee?: cosmos_base_v1beta1_coin_pb.Coin.AsObject,
    }
}

export class MsgFillBidsResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgFillBidsResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgFillBidsResponse): MsgFillBidsResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgFillBidsResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgFillBidsResponse;
    static deserializeBinaryFromReader(message: MsgFillBidsResponse, reader: jspb.BinaryReader): MsgFillBidsResponse;
}

export namespace MsgFillBidsResponse {
    export type AsObject = {
    }
}

export class MsgFillAsksRequest extends jspb.Message { 
    getBuyer(): string;
    setBuyer(value: string): MsgFillAsksRequest;
    getMarketId(): number;
    setMarketId(value: number): MsgFillAsksRequest;

    hasTotalPrice(): boolean;
    clearTotalPrice(): void;
    getTotalPrice(): cosmos_base_v1beta1_coin_pb.Coin | undefined;
    setTotalPrice(value?: cosmos_base_v1beta1_coin_pb.Coin): MsgFillAsksRequest;
    clearAskOrderIdsList(): void;
    getAskOrderIdsList(): Array<number>;
    setAskOrderIdsList(value: Array<number>): MsgFillAsksRequest;
    addAskOrderIds(value: number, index?: number): number;
    clearBuyerSettlementFeesList(): void;
    getBuyerSettlementFeesList(): Array<cosmos_base_v1beta1_coin_pb.Coin>;
    setBuyerSettlementFeesList(value: Array<cosmos_base_v1beta1_coin_pb.Coin>): MsgFillAsksRequest;
    addBuyerSettlementFees(value?: cosmos_base_v1beta1_coin_pb.Coin, index?: number): cosmos_base_v1beta1_coin_pb.Coin;

    hasBidOrderCreationFee(): boolean;
    clearBidOrderCreationFee(): void;
    getBidOrderCreationFee(): cosmos_base_v1beta1_coin_pb.Coin | undefined;
    setBidOrderCreationFee(value?: cosmos_base_v1beta1_coin_pb.Coin): MsgFillAsksRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgFillAsksRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgFillAsksRequest): MsgFillAsksRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgFillAsksRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgFillAsksRequest;
    static deserializeBinaryFromReader(message: MsgFillAsksRequest, reader: jspb.BinaryReader): MsgFillAsksRequest;
}

export namespace MsgFillAsksRequest {
    export type AsObject = {
        buyer: string,
        marketId: number,
        totalPrice?: cosmos_base_v1beta1_coin_pb.Coin.AsObject,
        askOrderIdsList: Array<number>,
        buyerSettlementFeesList: Array<cosmos_base_v1beta1_coin_pb.Coin.AsObject>,
        bidOrderCreationFee?: cosmos_base_v1beta1_coin_pb.Coin.AsObject,
    }
}

export class MsgFillAsksResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgFillAsksResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgFillAsksResponse): MsgFillAsksResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgFillAsksResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgFillAsksResponse;
    static deserializeBinaryFromReader(message: MsgFillAsksResponse, reader: jspb.BinaryReader): MsgFillAsksResponse;
}

export namespace MsgFillAsksResponse {
    export type AsObject = {
    }
}

export class MsgMarketSettleRequest extends jspb.Message { 
    getAdmin(): string;
    setAdmin(value: string): MsgMarketSettleRequest;
    getMarketId(): number;
    setMarketId(value: number): MsgMarketSettleRequest;
    clearAskOrderIdsList(): void;
    getAskOrderIdsList(): Array<number>;
    setAskOrderIdsList(value: Array<number>): MsgMarketSettleRequest;
    addAskOrderIds(value: number, index?: number): number;
    clearBidOrderIdsList(): void;
    getBidOrderIdsList(): Array<number>;
    setBidOrderIdsList(value: Array<number>): MsgMarketSettleRequest;
    addBidOrderIds(value: number, index?: number): number;
    getExpectPartial(): boolean;
    setExpectPartial(value: boolean): MsgMarketSettleRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgMarketSettleRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgMarketSettleRequest): MsgMarketSettleRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgMarketSettleRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgMarketSettleRequest;
    static deserializeBinaryFromReader(message: MsgMarketSettleRequest, reader: jspb.BinaryReader): MsgMarketSettleRequest;
}

export namespace MsgMarketSettleRequest {
    export type AsObject = {
        admin: string,
        marketId: number,
        askOrderIdsList: Array<number>,
        bidOrderIdsList: Array<number>,
        expectPartial: boolean,
    }
}

export class MsgMarketSettleResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgMarketSettleResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgMarketSettleResponse): MsgMarketSettleResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgMarketSettleResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgMarketSettleResponse;
    static deserializeBinaryFromReader(message: MsgMarketSettleResponse, reader: jspb.BinaryReader): MsgMarketSettleResponse;
}

export namespace MsgMarketSettleResponse {
    export type AsObject = {
    }
}

export class MsgMarketCommitmentSettleRequest extends jspb.Message { 
    getAdmin(): string;
    setAdmin(value: string): MsgMarketCommitmentSettleRequest;
    getMarketId(): number;
    setMarketId(value: number): MsgMarketCommitmentSettleRequest;
    clearInputsList(): void;
    getInputsList(): Array<provenance_exchange_v1_commitments_pb.AccountAmount>;
    setInputsList(value: Array<provenance_exchange_v1_commitments_pb.AccountAmount>): MsgMarketCommitmentSettleRequest;
    addInputs(value?: provenance_exchange_v1_commitments_pb.AccountAmount, index?: number): provenance_exchange_v1_commitments_pb.AccountAmount;
    clearOutputsList(): void;
    getOutputsList(): Array<provenance_exchange_v1_commitments_pb.AccountAmount>;
    setOutputsList(value: Array<provenance_exchange_v1_commitments_pb.AccountAmount>): MsgMarketCommitmentSettleRequest;
    addOutputs(value?: provenance_exchange_v1_commitments_pb.AccountAmount, index?: number): provenance_exchange_v1_commitments_pb.AccountAmount;
    clearFeesList(): void;
    getFeesList(): Array<provenance_exchange_v1_commitments_pb.AccountAmount>;
    setFeesList(value: Array<provenance_exchange_v1_commitments_pb.AccountAmount>): MsgMarketCommitmentSettleRequest;
    addFees(value?: provenance_exchange_v1_commitments_pb.AccountAmount, index?: number): provenance_exchange_v1_commitments_pb.AccountAmount;
    clearNavsList(): void;
    getNavsList(): Array<provenance_exchange_v1_commitments_pb.NetAssetPrice>;
    setNavsList(value: Array<provenance_exchange_v1_commitments_pb.NetAssetPrice>): MsgMarketCommitmentSettleRequest;
    addNavs(value?: provenance_exchange_v1_commitments_pb.NetAssetPrice, index?: number): provenance_exchange_v1_commitments_pb.NetAssetPrice;
    getEventTag(): string;
    setEventTag(value: string): MsgMarketCommitmentSettleRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgMarketCommitmentSettleRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgMarketCommitmentSettleRequest): MsgMarketCommitmentSettleRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgMarketCommitmentSettleRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgMarketCommitmentSettleRequest;
    static deserializeBinaryFromReader(message: MsgMarketCommitmentSettleRequest, reader: jspb.BinaryReader): MsgMarketCommitmentSettleRequest;
}

export namespace MsgMarketCommitmentSettleRequest {
    export type AsObject = {
        admin: string,
        marketId: number,
        inputsList: Array<provenance_exchange_v1_commitments_pb.AccountAmount.AsObject>,
        outputsList: Array<provenance_exchange_v1_commitments_pb.AccountAmount.AsObject>,
        feesList: Array<provenance_exchange_v1_commitments_pb.AccountAmount.AsObject>,
        navsList: Array<provenance_exchange_v1_commitments_pb.NetAssetPrice.AsObject>,
        eventTag: string,
    }
}

export class MsgMarketCommitmentSettleResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgMarketCommitmentSettleResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgMarketCommitmentSettleResponse): MsgMarketCommitmentSettleResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgMarketCommitmentSettleResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgMarketCommitmentSettleResponse;
    static deserializeBinaryFromReader(message: MsgMarketCommitmentSettleResponse, reader: jspb.BinaryReader): MsgMarketCommitmentSettleResponse;
}

export namespace MsgMarketCommitmentSettleResponse {
    export type AsObject = {
    }
}

export class MsgMarketReleaseCommitmentsRequest extends jspb.Message { 
    getAdmin(): string;
    setAdmin(value: string): MsgMarketReleaseCommitmentsRequest;
    getMarketId(): number;
    setMarketId(value: number): MsgMarketReleaseCommitmentsRequest;
    clearToReleaseList(): void;
    getToReleaseList(): Array<provenance_exchange_v1_commitments_pb.AccountAmount>;
    setToReleaseList(value: Array<provenance_exchange_v1_commitments_pb.AccountAmount>): MsgMarketReleaseCommitmentsRequest;
    addToRelease(value?: provenance_exchange_v1_commitments_pb.AccountAmount, index?: number): provenance_exchange_v1_commitments_pb.AccountAmount;
    getEventTag(): string;
    setEventTag(value: string): MsgMarketReleaseCommitmentsRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgMarketReleaseCommitmentsRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgMarketReleaseCommitmentsRequest): MsgMarketReleaseCommitmentsRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgMarketReleaseCommitmentsRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgMarketReleaseCommitmentsRequest;
    static deserializeBinaryFromReader(message: MsgMarketReleaseCommitmentsRequest, reader: jspb.BinaryReader): MsgMarketReleaseCommitmentsRequest;
}

export namespace MsgMarketReleaseCommitmentsRequest {
    export type AsObject = {
        admin: string,
        marketId: number,
        toReleaseList: Array<provenance_exchange_v1_commitments_pb.AccountAmount.AsObject>,
        eventTag: string,
    }
}

export class MsgMarketReleaseCommitmentsResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgMarketReleaseCommitmentsResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgMarketReleaseCommitmentsResponse): MsgMarketReleaseCommitmentsResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgMarketReleaseCommitmentsResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgMarketReleaseCommitmentsResponse;
    static deserializeBinaryFromReader(message: MsgMarketReleaseCommitmentsResponse, reader: jspb.BinaryReader): MsgMarketReleaseCommitmentsResponse;
}

export namespace MsgMarketReleaseCommitmentsResponse {
    export type AsObject = {
    }
}

export class MsgMarketSetOrderExternalIDRequest extends jspb.Message { 
    getAdmin(): string;
    setAdmin(value: string): MsgMarketSetOrderExternalIDRequest;
    getMarketId(): number;
    setMarketId(value: number): MsgMarketSetOrderExternalIDRequest;
    getOrderId(): number;
    setOrderId(value: number): MsgMarketSetOrderExternalIDRequest;
    getExternalId(): string;
    setExternalId(value: string): MsgMarketSetOrderExternalIDRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgMarketSetOrderExternalIDRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgMarketSetOrderExternalIDRequest): MsgMarketSetOrderExternalIDRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgMarketSetOrderExternalIDRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgMarketSetOrderExternalIDRequest;
    static deserializeBinaryFromReader(message: MsgMarketSetOrderExternalIDRequest, reader: jspb.BinaryReader): MsgMarketSetOrderExternalIDRequest;
}

export namespace MsgMarketSetOrderExternalIDRequest {
    export type AsObject = {
        admin: string,
        marketId: number,
        orderId: number,
        externalId: string,
    }
}

export class MsgMarketSetOrderExternalIDResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgMarketSetOrderExternalIDResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgMarketSetOrderExternalIDResponse): MsgMarketSetOrderExternalIDResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgMarketSetOrderExternalIDResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgMarketSetOrderExternalIDResponse;
    static deserializeBinaryFromReader(message: MsgMarketSetOrderExternalIDResponse, reader: jspb.BinaryReader): MsgMarketSetOrderExternalIDResponse;
}

export namespace MsgMarketSetOrderExternalIDResponse {
    export type AsObject = {
    }
}

export class MsgMarketWithdrawRequest extends jspb.Message { 
    getAdmin(): string;
    setAdmin(value: string): MsgMarketWithdrawRequest;
    getMarketId(): number;
    setMarketId(value: number): MsgMarketWithdrawRequest;
    getToAddress(): string;
    setToAddress(value: string): MsgMarketWithdrawRequest;
    clearAmountList(): void;
    getAmountList(): Array<cosmos_base_v1beta1_coin_pb.Coin>;
    setAmountList(value: Array<cosmos_base_v1beta1_coin_pb.Coin>): MsgMarketWithdrawRequest;
    addAmount(value?: cosmos_base_v1beta1_coin_pb.Coin, index?: number): cosmos_base_v1beta1_coin_pb.Coin;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgMarketWithdrawRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgMarketWithdrawRequest): MsgMarketWithdrawRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgMarketWithdrawRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgMarketWithdrawRequest;
    static deserializeBinaryFromReader(message: MsgMarketWithdrawRequest, reader: jspb.BinaryReader): MsgMarketWithdrawRequest;
}

export namespace MsgMarketWithdrawRequest {
    export type AsObject = {
        admin: string,
        marketId: number,
        toAddress: string,
        amountList: Array<cosmos_base_v1beta1_coin_pb.Coin.AsObject>,
    }
}

export class MsgMarketWithdrawResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgMarketWithdrawResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgMarketWithdrawResponse): MsgMarketWithdrawResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgMarketWithdrawResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgMarketWithdrawResponse;
    static deserializeBinaryFromReader(message: MsgMarketWithdrawResponse, reader: jspb.BinaryReader): MsgMarketWithdrawResponse;
}

export namespace MsgMarketWithdrawResponse {
    export type AsObject = {
    }
}

export class MsgMarketUpdateDetailsRequest extends jspb.Message { 
    getAdmin(): string;
    setAdmin(value: string): MsgMarketUpdateDetailsRequest;
    getMarketId(): number;
    setMarketId(value: number): MsgMarketUpdateDetailsRequest;

    hasMarketDetails(): boolean;
    clearMarketDetails(): void;
    getMarketDetails(): provenance_exchange_v1_market_pb.MarketDetails | undefined;
    setMarketDetails(value?: provenance_exchange_v1_market_pb.MarketDetails): MsgMarketUpdateDetailsRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgMarketUpdateDetailsRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgMarketUpdateDetailsRequest): MsgMarketUpdateDetailsRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgMarketUpdateDetailsRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgMarketUpdateDetailsRequest;
    static deserializeBinaryFromReader(message: MsgMarketUpdateDetailsRequest, reader: jspb.BinaryReader): MsgMarketUpdateDetailsRequest;
}

export namespace MsgMarketUpdateDetailsRequest {
    export type AsObject = {
        admin: string,
        marketId: number,
        marketDetails?: provenance_exchange_v1_market_pb.MarketDetails.AsObject,
    }
}

export class MsgMarketUpdateDetailsResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgMarketUpdateDetailsResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgMarketUpdateDetailsResponse): MsgMarketUpdateDetailsResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgMarketUpdateDetailsResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgMarketUpdateDetailsResponse;
    static deserializeBinaryFromReader(message: MsgMarketUpdateDetailsResponse, reader: jspb.BinaryReader): MsgMarketUpdateDetailsResponse;
}

export namespace MsgMarketUpdateDetailsResponse {
    export type AsObject = {
    }
}

export class MsgMarketUpdateEnabledRequest extends jspb.Message { 
    getAdmin(): string;
    setAdmin(value: string): MsgMarketUpdateEnabledRequest;
    getMarketId(): number;
    setMarketId(value: number): MsgMarketUpdateEnabledRequest;
    getAcceptingOrders(): boolean;
    setAcceptingOrders(value: boolean): MsgMarketUpdateEnabledRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgMarketUpdateEnabledRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgMarketUpdateEnabledRequest): MsgMarketUpdateEnabledRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgMarketUpdateEnabledRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgMarketUpdateEnabledRequest;
    static deserializeBinaryFromReader(message: MsgMarketUpdateEnabledRequest, reader: jspb.BinaryReader): MsgMarketUpdateEnabledRequest;
}

export namespace MsgMarketUpdateEnabledRequest {
    export type AsObject = {
        admin: string,
        marketId: number,
        acceptingOrders: boolean,
    }
}

export class MsgMarketUpdateEnabledResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgMarketUpdateEnabledResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgMarketUpdateEnabledResponse): MsgMarketUpdateEnabledResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgMarketUpdateEnabledResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgMarketUpdateEnabledResponse;
    static deserializeBinaryFromReader(message: MsgMarketUpdateEnabledResponse, reader: jspb.BinaryReader): MsgMarketUpdateEnabledResponse;
}

export namespace MsgMarketUpdateEnabledResponse {
    export type AsObject = {
    }
}

export class MsgMarketUpdateAcceptingOrdersRequest extends jspb.Message { 
    getAdmin(): string;
    setAdmin(value: string): MsgMarketUpdateAcceptingOrdersRequest;
    getMarketId(): number;
    setMarketId(value: number): MsgMarketUpdateAcceptingOrdersRequest;
    getAcceptingOrders(): boolean;
    setAcceptingOrders(value: boolean): MsgMarketUpdateAcceptingOrdersRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgMarketUpdateAcceptingOrdersRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgMarketUpdateAcceptingOrdersRequest): MsgMarketUpdateAcceptingOrdersRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgMarketUpdateAcceptingOrdersRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgMarketUpdateAcceptingOrdersRequest;
    static deserializeBinaryFromReader(message: MsgMarketUpdateAcceptingOrdersRequest, reader: jspb.BinaryReader): MsgMarketUpdateAcceptingOrdersRequest;
}

export namespace MsgMarketUpdateAcceptingOrdersRequest {
    export type AsObject = {
        admin: string,
        marketId: number,
        acceptingOrders: boolean,
    }
}

export class MsgMarketUpdateAcceptingOrdersResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgMarketUpdateAcceptingOrdersResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgMarketUpdateAcceptingOrdersResponse): MsgMarketUpdateAcceptingOrdersResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgMarketUpdateAcceptingOrdersResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgMarketUpdateAcceptingOrdersResponse;
    static deserializeBinaryFromReader(message: MsgMarketUpdateAcceptingOrdersResponse, reader: jspb.BinaryReader): MsgMarketUpdateAcceptingOrdersResponse;
}

export namespace MsgMarketUpdateAcceptingOrdersResponse {
    export type AsObject = {
    }
}

export class MsgMarketUpdateUserSettleRequest extends jspb.Message { 
    getAdmin(): string;
    setAdmin(value: string): MsgMarketUpdateUserSettleRequest;
    getMarketId(): number;
    setMarketId(value: number): MsgMarketUpdateUserSettleRequest;
    getAllowUserSettlement(): boolean;
    setAllowUserSettlement(value: boolean): MsgMarketUpdateUserSettleRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgMarketUpdateUserSettleRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgMarketUpdateUserSettleRequest): MsgMarketUpdateUserSettleRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgMarketUpdateUserSettleRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgMarketUpdateUserSettleRequest;
    static deserializeBinaryFromReader(message: MsgMarketUpdateUserSettleRequest, reader: jspb.BinaryReader): MsgMarketUpdateUserSettleRequest;
}

export namespace MsgMarketUpdateUserSettleRequest {
    export type AsObject = {
        admin: string,
        marketId: number,
        allowUserSettlement: boolean,
    }
}

export class MsgMarketUpdateUserSettleResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgMarketUpdateUserSettleResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgMarketUpdateUserSettleResponse): MsgMarketUpdateUserSettleResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgMarketUpdateUserSettleResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgMarketUpdateUserSettleResponse;
    static deserializeBinaryFromReader(message: MsgMarketUpdateUserSettleResponse, reader: jspb.BinaryReader): MsgMarketUpdateUserSettleResponse;
}

export namespace MsgMarketUpdateUserSettleResponse {
    export type AsObject = {
    }
}

export class MsgMarketUpdateAcceptingCommitmentsRequest extends jspb.Message { 
    getAdmin(): string;
    setAdmin(value: string): MsgMarketUpdateAcceptingCommitmentsRequest;
    getMarketId(): number;
    setMarketId(value: number): MsgMarketUpdateAcceptingCommitmentsRequest;
    getAcceptingCommitments(): boolean;
    setAcceptingCommitments(value: boolean): MsgMarketUpdateAcceptingCommitmentsRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgMarketUpdateAcceptingCommitmentsRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgMarketUpdateAcceptingCommitmentsRequest): MsgMarketUpdateAcceptingCommitmentsRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgMarketUpdateAcceptingCommitmentsRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgMarketUpdateAcceptingCommitmentsRequest;
    static deserializeBinaryFromReader(message: MsgMarketUpdateAcceptingCommitmentsRequest, reader: jspb.BinaryReader): MsgMarketUpdateAcceptingCommitmentsRequest;
}

export namespace MsgMarketUpdateAcceptingCommitmentsRequest {
    export type AsObject = {
        admin: string,
        marketId: number,
        acceptingCommitments: boolean,
    }
}

export class MsgMarketUpdateAcceptingCommitmentsResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgMarketUpdateAcceptingCommitmentsResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgMarketUpdateAcceptingCommitmentsResponse): MsgMarketUpdateAcceptingCommitmentsResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgMarketUpdateAcceptingCommitmentsResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgMarketUpdateAcceptingCommitmentsResponse;
    static deserializeBinaryFromReader(message: MsgMarketUpdateAcceptingCommitmentsResponse, reader: jspb.BinaryReader): MsgMarketUpdateAcceptingCommitmentsResponse;
}

export namespace MsgMarketUpdateAcceptingCommitmentsResponse {
    export type AsObject = {
    }
}

export class MsgMarketUpdateIntermediaryDenomRequest extends jspb.Message { 
    getAdmin(): string;
    setAdmin(value: string): MsgMarketUpdateIntermediaryDenomRequest;
    getMarketId(): number;
    setMarketId(value: number): MsgMarketUpdateIntermediaryDenomRequest;
    getIntermediaryDenom(): string;
    setIntermediaryDenom(value: string): MsgMarketUpdateIntermediaryDenomRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgMarketUpdateIntermediaryDenomRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgMarketUpdateIntermediaryDenomRequest): MsgMarketUpdateIntermediaryDenomRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgMarketUpdateIntermediaryDenomRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgMarketUpdateIntermediaryDenomRequest;
    static deserializeBinaryFromReader(message: MsgMarketUpdateIntermediaryDenomRequest, reader: jspb.BinaryReader): MsgMarketUpdateIntermediaryDenomRequest;
}

export namespace MsgMarketUpdateIntermediaryDenomRequest {
    export type AsObject = {
        admin: string,
        marketId: number,
        intermediaryDenom: string,
    }
}

export class MsgMarketUpdateIntermediaryDenomResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgMarketUpdateIntermediaryDenomResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgMarketUpdateIntermediaryDenomResponse): MsgMarketUpdateIntermediaryDenomResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgMarketUpdateIntermediaryDenomResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgMarketUpdateIntermediaryDenomResponse;
    static deserializeBinaryFromReader(message: MsgMarketUpdateIntermediaryDenomResponse, reader: jspb.BinaryReader): MsgMarketUpdateIntermediaryDenomResponse;
}

export namespace MsgMarketUpdateIntermediaryDenomResponse {
    export type AsObject = {
    }
}

export class MsgMarketManagePermissionsRequest extends jspb.Message { 
    getAdmin(): string;
    setAdmin(value: string): MsgMarketManagePermissionsRequest;
    getMarketId(): number;
    setMarketId(value: number): MsgMarketManagePermissionsRequest;
    clearRevokeAllList(): void;
    getRevokeAllList(): Array<string>;
    setRevokeAllList(value: Array<string>): MsgMarketManagePermissionsRequest;
    addRevokeAll(value: string, index?: number): string;
    clearToRevokeList(): void;
    getToRevokeList(): Array<provenance_exchange_v1_market_pb.AccessGrant>;
    setToRevokeList(value: Array<provenance_exchange_v1_market_pb.AccessGrant>): MsgMarketManagePermissionsRequest;
    addToRevoke(value?: provenance_exchange_v1_market_pb.AccessGrant, index?: number): provenance_exchange_v1_market_pb.AccessGrant;
    clearToGrantList(): void;
    getToGrantList(): Array<provenance_exchange_v1_market_pb.AccessGrant>;
    setToGrantList(value: Array<provenance_exchange_v1_market_pb.AccessGrant>): MsgMarketManagePermissionsRequest;
    addToGrant(value?: provenance_exchange_v1_market_pb.AccessGrant, index?: number): provenance_exchange_v1_market_pb.AccessGrant;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgMarketManagePermissionsRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgMarketManagePermissionsRequest): MsgMarketManagePermissionsRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgMarketManagePermissionsRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgMarketManagePermissionsRequest;
    static deserializeBinaryFromReader(message: MsgMarketManagePermissionsRequest, reader: jspb.BinaryReader): MsgMarketManagePermissionsRequest;
}

export namespace MsgMarketManagePermissionsRequest {
    export type AsObject = {
        admin: string,
        marketId: number,
        revokeAllList: Array<string>,
        toRevokeList: Array<provenance_exchange_v1_market_pb.AccessGrant.AsObject>,
        toGrantList: Array<provenance_exchange_v1_market_pb.AccessGrant.AsObject>,
    }
}

export class MsgMarketManagePermissionsResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgMarketManagePermissionsResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgMarketManagePermissionsResponse): MsgMarketManagePermissionsResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgMarketManagePermissionsResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgMarketManagePermissionsResponse;
    static deserializeBinaryFromReader(message: MsgMarketManagePermissionsResponse, reader: jspb.BinaryReader): MsgMarketManagePermissionsResponse;
}

export namespace MsgMarketManagePermissionsResponse {
    export type AsObject = {
    }
}

export class MsgMarketManageReqAttrsRequest extends jspb.Message { 
    getAdmin(): string;
    setAdmin(value: string): MsgMarketManageReqAttrsRequest;
    getMarketId(): number;
    setMarketId(value: number): MsgMarketManageReqAttrsRequest;
    clearCreateAskToAddList(): void;
    getCreateAskToAddList(): Array<string>;
    setCreateAskToAddList(value: Array<string>): MsgMarketManageReqAttrsRequest;
    addCreateAskToAdd(value: string, index?: number): string;
    clearCreateAskToRemoveList(): void;
    getCreateAskToRemoveList(): Array<string>;
    setCreateAskToRemoveList(value: Array<string>): MsgMarketManageReqAttrsRequest;
    addCreateAskToRemove(value: string, index?: number): string;
    clearCreateBidToAddList(): void;
    getCreateBidToAddList(): Array<string>;
    setCreateBidToAddList(value: Array<string>): MsgMarketManageReqAttrsRequest;
    addCreateBidToAdd(value: string, index?: number): string;
    clearCreateBidToRemoveList(): void;
    getCreateBidToRemoveList(): Array<string>;
    setCreateBidToRemoveList(value: Array<string>): MsgMarketManageReqAttrsRequest;
    addCreateBidToRemove(value: string, index?: number): string;
    clearCreateCommitmentToAddList(): void;
    getCreateCommitmentToAddList(): Array<string>;
    setCreateCommitmentToAddList(value: Array<string>): MsgMarketManageReqAttrsRequest;
    addCreateCommitmentToAdd(value: string, index?: number): string;
    clearCreateCommitmentToRemoveList(): void;
    getCreateCommitmentToRemoveList(): Array<string>;
    setCreateCommitmentToRemoveList(value: Array<string>): MsgMarketManageReqAttrsRequest;
    addCreateCommitmentToRemove(value: string, index?: number): string;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgMarketManageReqAttrsRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgMarketManageReqAttrsRequest): MsgMarketManageReqAttrsRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgMarketManageReqAttrsRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgMarketManageReqAttrsRequest;
    static deserializeBinaryFromReader(message: MsgMarketManageReqAttrsRequest, reader: jspb.BinaryReader): MsgMarketManageReqAttrsRequest;
}

export namespace MsgMarketManageReqAttrsRequest {
    export type AsObject = {
        admin: string,
        marketId: number,
        createAskToAddList: Array<string>,
        createAskToRemoveList: Array<string>,
        createBidToAddList: Array<string>,
        createBidToRemoveList: Array<string>,
        createCommitmentToAddList: Array<string>,
        createCommitmentToRemoveList: Array<string>,
    }
}

export class MsgMarketManageReqAttrsResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgMarketManageReqAttrsResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgMarketManageReqAttrsResponse): MsgMarketManageReqAttrsResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgMarketManageReqAttrsResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgMarketManageReqAttrsResponse;
    static deserializeBinaryFromReader(message: MsgMarketManageReqAttrsResponse, reader: jspb.BinaryReader): MsgMarketManageReqAttrsResponse;
}

export namespace MsgMarketManageReqAttrsResponse {
    export type AsObject = {
    }
}

export class MsgCreatePaymentRequest extends jspb.Message { 

    hasPayment(): boolean;
    clearPayment(): void;
    getPayment(): provenance_exchange_v1_payments_pb.Payment | undefined;
    setPayment(value?: provenance_exchange_v1_payments_pb.Payment): MsgCreatePaymentRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgCreatePaymentRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgCreatePaymentRequest): MsgCreatePaymentRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgCreatePaymentRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgCreatePaymentRequest;
    static deserializeBinaryFromReader(message: MsgCreatePaymentRequest, reader: jspb.BinaryReader): MsgCreatePaymentRequest;
}

export namespace MsgCreatePaymentRequest {
    export type AsObject = {
        payment?: provenance_exchange_v1_payments_pb.Payment.AsObject,
    }
}

export class MsgCreatePaymentResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgCreatePaymentResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgCreatePaymentResponse): MsgCreatePaymentResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgCreatePaymentResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgCreatePaymentResponse;
    static deserializeBinaryFromReader(message: MsgCreatePaymentResponse, reader: jspb.BinaryReader): MsgCreatePaymentResponse;
}

export namespace MsgCreatePaymentResponse {
    export type AsObject = {
    }
}

export class MsgAcceptPaymentRequest extends jspb.Message { 

    hasPayment(): boolean;
    clearPayment(): void;
    getPayment(): provenance_exchange_v1_payments_pb.Payment | undefined;
    setPayment(value?: provenance_exchange_v1_payments_pb.Payment): MsgAcceptPaymentRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgAcceptPaymentRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgAcceptPaymentRequest): MsgAcceptPaymentRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgAcceptPaymentRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgAcceptPaymentRequest;
    static deserializeBinaryFromReader(message: MsgAcceptPaymentRequest, reader: jspb.BinaryReader): MsgAcceptPaymentRequest;
}

export namespace MsgAcceptPaymentRequest {
    export type AsObject = {
        payment?: provenance_exchange_v1_payments_pb.Payment.AsObject,
    }
}

export class MsgAcceptPaymentResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgAcceptPaymentResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgAcceptPaymentResponse): MsgAcceptPaymentResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgAcceptPaymentResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgAcceptPaymentResponse;
    static deserializeBinaryFromReader(message: MsgAcceptPaymentResponse, reader: jspb.BinaryReader): MsgAcceptPaymentResponse;
}

export namespace MsgAcceptPaymentResponse {
    export type AsObject = {
    }
}

export class MsgRejectPaymentRequest extends jspb.Message { 
    getTarget(): string;
    setTarget(value: string): MsgRejectPaymentRequest;
    getSource(): string;
    setSource(value: string): MsgRejectPaymentRequest;
    getExternalId(): string;
    setExternalId(value: string): MsgRejectPaymentRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgRejectPaymentRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgRejectPaymentRequest): MsgRejectPaymentRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgRejectPaymentRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgRejectPaymentRequest;
    static deserializeBinaryFromReader(message: MsgRejectPaymentRequest, reader: jspb.BinaryReader): MsgRejectPaymentRequest;
}

export namespace MsgRejectPaymentRequest {
    export type AsObject = {
        target: string,
        source: string,
        externalId: string,
    }
}

export class MsgRejectPaymentResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgRejectPaymentResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgRejectPaymentResponse): MsgRejectPaymentResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgRejectPaymentResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgRejectPaymentResponse;
    static deserializeBinaryFromReader(message: MsgRejectPaymentResponse, reader: jspb.BinaryReader): MsgRejectPaymentResponse;
}

export namespace MsgRejectPaymentResponse {
    export type AsObject = {
    }
}

export class MsgRejectPaymentsRequest extends jspb.Message { 
    getTarget(): string;
    setTarget(value: string): MsgRejectPaymentsRequest;
    clearSourcesList(): void;
    getSourcesList(): Array<string>;
    setSourcesList(value: Array<string>): MsgRejectPaymentsRequest;
    addSources(value: string, index?: number): string;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgRejectPaymentsRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgRejectPaymentsRequest): MsgRejectPaymentsRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgRejectPaymentsRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgRejectPaymentsRequest;
    static deserializeBinaryFromReader(message: MsgRejectPaymentsRequest, reader: jspb.BinaryReader): MsgRejectPaymentsRequest;
}

export namespace MsgRejectPaymentsRequest {
    export type AsObject = {
        target: string,
        sourcesList: Array<string>,
    }
}

export class MsgRejectPaymentsResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgRejectPaymentsResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgRejectPaymentsResponse): MsgRejectPaymentsResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgRejectPaymentsResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgRejectPaymentsResponse;
    static deserializeBinaryFromReader(message: MsgRejectPaymentsResponse, reader: jspb.BinaryReader): MsgRejectPaymentsResponse;
}

export namespace MsgRejectPaymentsResponse {
    export type AsObject = {
    }
}

export class MsgCancelPaymentsRequest extends jspb.Message { 
    getSource(): string;
    setSource(value: string): MsgCancelPaymentsRequest;
    clearExternalIdsList(): void;
    getExternalIdsList(): Array<string>;
    setExternalIdsList(value: Array<string>): MsgCancelPaymentsRequest;
    addExternalIds(value: string, index?: number): string;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgCancelPaymentsRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgCancelPaymentsRequest): MsgCancelPaymentsRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgCancelPaymentsRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgCancelPaymentsRequest;
    static deserializeBinaryFromReader(message: MsgCancelPaymentsRequest, reader: jspb.BinaryReader): MsgCancelPaymentsRequest;
}

export namespace MsgCancelPaymentsRequest {
    export type AsObject = {
        source: string,
        externalIdsList: Array<string>,
    }
}

export class MsgCancelPaymentsResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgCancelPaymentsResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgCancelPaymentsResponse): MsgCancelPaymentsResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgCancelPaymentsResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgCancelPaymentsResponse;
    static deserializeBinaryFromReader(message: MsgCancelPaymentsResponse, reader: jspb.BinaryReader): MsgCancelPaymentsResponse;
}

export namespace MsgCancelPaymentsResponse {
    export type AsObject = {
    }
}

export class MsgChangePaymentTargetRequest extends jspb.Message { 
    getSource(): string;
    setSource(value: string): MsgChangePaymentTargetRequest;
    getExternalId(): string;
    setExternalId(value: string): MsgChangePaymentTargetRequest;
    getNewTarget(): string;
    setNewTarget(value: string): MsgChangePaymentTargetRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgChangePaymentTargetRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgChangePaymentTargetRequest): MsgChangePaymentTargetRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgChangePaymentTargetRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgChangePaymentTargetRequest;
    static deserializeBinaryFromReader(message: MsgChangePaymentTargetRequest, reader: jspb.BinaryReader): MsgChangePaymentTargetRequest;
}

export namespace MsgChangePaymentTargetRequest {
    export type AsObject = {
        source: string,
        externalId: string,
        newTarget: string,
    }
}

export class MsgChangePaymentTargetResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgChangePaymentTargetResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgChangePaymentTargetResponse): MsgChangePaymentTargetResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgChangePaymentTargetResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgChangePaymentTargetResponse;
    static deserializeBinaryFromReader(message: MsgChangePaymentTargetResponse, reader: jspb.BinaryReader): MsgChangePaymentTargetResponse;
}

export namespace MsgChangePaymentTargetResponse {
    export type AsObject = {
    }
}

export class MsgGovCreateMarketRequest extends jspb.Message { 
    getAuthority(): string;
    setAuthority(value: string): MsgGovCreateMarketRequest;

    hasMarket(): boolean;
    clearMarket(): void;
    getMarket(): provenance_exchange_v1_market_pb.Market | undefined;
    setMarket(value?: provenance_exchange_v1_market_pb.Market): MsgGovCreateMarketRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgGovCreateMarketRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgGovCreateMarketRequest): MsgGovCreateMarketRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgGovCreateMarketRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgGovCreateMarketRequest;
    static deserializeBinaryFromReader(message: MsgGovCreateMarketRequest, reader: jspb.BinaryReader): MsgGovCreateMarketRequest;
}

export namespace MsgGovCreateMarketRequest {
    export type AsObject = {
        authority: string,
        market?: provenance_exchange_v1_market_pb.Market.AsObject,
    }
}

export class MsgGovCreateMarketResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgGovCreateMarketResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgGovCreateMarketResponse): MsgGovCreateMarketResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgGovCreateMarketResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgGovCreateMarketResponse;
    static deserializeBinaryFromReader(message: MsgGovCreateMarketResponse, reader: jspb.BinaryReader): MsgGovCreateMarketResponse;
}

export namespace MsgGovCreateMarketResponse {
    export type AsObject = {
    }
}

export class MsgGovManageFeesRequest extends jspb.Message { 
    getAuthority(): string;
    setAuthority(value: string): MsgGovManageFeesRequest;
    getMarketId(): number;
    setMarketId(value: number): MsgGovManageFeesRequest;
    clearAddFeeCreateAskFlatList(): void;
    getAddFeeCreateAskFlatList(): Array<cosmos_base_v1beta1_coin_pb.Coin>;
    setAddFeeCreateAskFlatList(value: Array<cosmos_base_v1beta1_coin_pb.Coin>): MsgGovManageFeesRequest;
    addAddFeeCreateAskFlat(value?: cosmos_base_v1beta1_coin_pb.Coin, index?: number): cosmos_base_v1beta1_coin_pb.Coin;
    clearRemoveFeeCreateAskFlatList(): void;
    getRemoveFeeCreateAskFlatList(): Array<cosmos_base_v1beta1_coin_pb.Coin>;
    setRemoveFeeCreateAskFlatList(value: Array<cosmos_base_v1beta1_coin_pb.Coin>): MsgGovManageFeesRequest;
    addRemoveFeeCreateAskFlat(value?: cosmos_base_v1beta1_coin_pb.Coin, index?: number): cosmos_base_v1beta1_coin_pb.Coin;
    clearAddFeeCreateBidFlatList(): void;
    getAddFeeCreateBidFlatList(): Array<cosmos_base_v1beta1_coin_pb.Coin>;
    setAddFeeCreateBidFlatList(value: Array<cosmos_base_v1beta1_coin_pb.Coin>): MsgGovManageFeesRequest;
    addAddFeeCreateBidFlat(value?: cosmos_base_v1beta1_coin_pb.Coin, index?: number): cosmos_base_v1beta1_coin_pb.Coin;
    clearRemoveFeeCreateBidFlatList(): void;
    getRemoveFeeCreateBidFlatList(): Array<cosmos_base_v1beta1_coin_pb.Coin>;
    setRemoveFeeCreateBidFlatList(value: Array<cosmos_base_v1beta1_coin_pb.Coin>): MsgGovManageFeesRequest;
    addRemoveFeeCreateBidFlat(value?: cosmos_base_v1beta1_coin_pb.Coin, index?: number): cosmos_base_v1beta1_coin_pb.Coin;
    clearAddFeeSellerSettlementFlatList(): void;
    getAddFeeSellerSettlementFlatList(): Array<cosmos_base_v1beta1_coin_pb.Coin>;
    setAddFeeSellerSettlementFlatList(value: Array<cosmos_base_v1beta1_coin_pb.Coin>): MsgGovManageFeesRequest;
    addAddFeeSellerSettlementFlat(value?: cosmos_base_v1beta1_coin_pb.Coin, index?: number): cosmos_base_v1beta1_coin_pb.Coin;
    clearRemoveFeeSellerSettlementFlatList(): void;
    getRemoveFeeSellerSettlementFlatList(): Array<cosmos_base_v1beta1_coin_pb.Coin>;
    setRemoveFeeSellerSettlementFlatList(value: Array<cosmos_base_v1beta1_coin_pb.Coin>): MsgGovManageFeesRequest;
    addRemoveFeeSellerSettlementFlat(value?: cosmos_base_v1beta1_coin_pb.Coin, index?: number): cosmos_base_v1beta1_coin_pb.Coin;
    clearAddFeeSellerSettlementRatiosList(): void;
    getAddFeeSellerSettlementRatiosList(): Array<provenance_exchange_v1_market_pb.FeeRatio>;
    setAddFeeSellerSettlementRatiosList(value: Array<provenance_exchange_v1_market_pb.FeeRatio>): MsgGovManageFeesRequest;
    addAddFeeSellerSettlementRatios(value?: provenance_exchange_v1_market_pb.FeeRatio, index?: number): provenance_exchange_v1_market_pb.FeeRatio;
    clearRemoveFeeSellerSettlementRatiosList(): void;
    getRemoveFeeSellerSettlementRatiosList(): Array<provenance_exchange_v1_market_pb.FeeRatio>;
    setRemoveFeeSellerSettlementRatiosList(value: Array<provenance_exchange_v1_market_pb.FeeRatio>): MsgGovManageFeesRequest;
    addRemoveFeeSellerSettlementRatios(value?: provenance_exchange_v1_market_pb.FeeRatio, index?: number): provenance_exchange_v1_market_pb.FeeRatio;
    clearAddFeeBuyerSettlementFlatList(): void;
    getAddFeeBuyerSettlementFlatList(): Array<cosmos_base_v1beta1_coin_pb.Coin>;
    setAddFeeBuyerSettlementFlatList(value: Array<cosmos_base_v1beta1_coin_pb.Coin>): MsgGovManageFeesRequest;
    addAddFeeBuyerSettlementFlat(value?: cosmos_base_v1beta1_coin_pb.Coin, index?: number): cosmos_base_v1beta1_coin_pb.Coin;
    clearRemoveFeeBuyerSettlementFlatList(): void;
    getRemoveFeeBuyerSettlementFlatList(): Array<cosmos_base_v1beta1_coin_pb.Coin>;
    setRemoveFeeBuyerSettlementFlatList(value: Array<cosmos_base_v1beta1_coin_pb.Coin>): MsgGovManageFeesRequest;
    addRemoveFeeBuyerSettlementFlat(value?: cosmos_base_v1beta1_coin_pb.Coin, index?: number): cosmos_base_v1beta1_coin_pb.Coin;
    clearAddFeeBuyerSettlementRatiosList(): void;
    getAddFeeBuyerSettlementRatiosList(): Array<provenance_exchange_v1_market_pb.FeeRatio>;
    setAddFeeBuyerSettlementRatiosList(value: Array<provenance_exchange_v1_market_pb.FeeRatio>): MsgGovManageFeesRequest;
    addAddFeeBuyerSettlementRatios(value?: provenance_exchange_v1_market_pb.FeeRatio, index?: number): provenance_exchange_v1_market_pb.FeeRatio;
    clearRemoveFeeBuyerSettlementRatiosList(): void;
    getRemoveFeeBuyerSettlementRatiosList(): Array<provenance_exchange_v1_market_pb.FeeRatio>;
    setRemoveFeeBuyerSettlementRatiosList(value: Array<provenance_exchange_v1_market_pb.FeeRatio>): MsgGovManageFeesRequest;
    addRemoveFeeBuyerSettlementRatios(value?: provenance_exchange_v1_market_pb.FeeRatio, index?: number): provenance_exchange_v1_market_pb.FeeRatio;
    clearAddFeeCreateCommitmentFlatList(): void;
    getAddFeeCreateCommitmentFlatList(): Array<cosmos_base_v1beta1_coin_pb.Coin>;
    setAddFeeCreateCommitmentFlatList(value: Array<cosmos_base_v1beta1_coin_pb.Coin>): MsgGovManageFeesRequest;
    addAddFeeCreateCommitmentFlat(value?: cosmos_base_v1beta1_coin_pb.Coin, index?: number): cosmos_base_v1beta1_coin_pb.Coin;
    clearRemoveFeeCreateCommitmentFlatList(): void;
    getRemoveFeeCreateCommitmentFlatList(): Array<cosmos_base_v1beta1_coin_pb.Coin>;
    setRemoveFeeCreateCommitmentFlatList(value: Array<cosmos_base_v1beta1_coin_pb.Coin>): MsgGovManageFeesRequest;
    addRemoveFeeCreateCommitmentFlat(value?: cosmos_base_v1beta1_coin_pb.Coin, index?: number): cosmos_base_v1beta1_coin_pb.Coin;
    getSetFeeCommitmentSettlementBips(): number;
    setSetFeeCommitmentSettlementBips(value: number): MsgGovManageFeesRequest;
    getUnsetFeeCommitmentSettlementBips(): boolean;
    setUnsetFeeCommitmentSettlementBips(value: boolean): MsgGovManageFeesRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgGovManageFeesRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgGovManageFeesRequest): MsgGovManageFeesRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgGovManageFeesRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgGovManageFeesRequest;
    static deserializeBinaryFromReader(message: MsgGovManageFeesRequest, reader: jspb.BinaryReader): MsgGovManageFeesRequest;
}

export namespace MsgGovManageFeesRequest {
    export type AsObject = {
        authority: string,
        marketId: number,
        addFeeCreateAskFlatList: Array<cosmos_base_v1beta1_coin_pb.Coin.AsObject>,
        removeFeeCreateAskFlatList: Array<cosmos_base_v1beta1_coin_pb.Coin.AsObject>,
        addFeeCreateBidFlatList: Array<cosmos_base_v1beta1_coin_pb.Coin.AsObject>,
        removeFeeCreateBidFlatList: Array<cosmos_base_v1beta1_coin_pb.Coin.AsObject>,
        addFeeSellerSettlementFlatList: Array<cosmos_base_v1beta1_coin_pb.Coin.AsObject>,
        removeFeeSellerSettlementFlatList: Array<cosmos_base_v1beta1_coin_pb.Coin.AsObject>,
        addFeeSellerSettlementRatiosList: Array<provenance_exchange_v1_market_pb.FeeRatio.AsObject>,
        removeFeeSellerSettlementRatiosList: Array<provenance_exchange_v1_market_pb.FeeRatio.AsObject>,
        addFeeBuyerSettlementFlatList: Array<cosmos_base_v1beta1_coin_pb.Coin.AsObject>,
        removeFeeBuyerSettlementFlatList: Array<cosmos_base_v1beta1_coin_pb.Coin.AsObject>,
        addFeeBuyerSettlementRatiosList: Array<provenance_exchange_v1_market_pb.FeeRatio.AsObject>,
        removeFeeBuyerSettlementRatiosList: Array<provenance_exchange_v1_market_pb.FeeRatio.AsObject>,
        addFeeCreateCommitmentFlatList: Array<cosmos_base_v1beta1_coin_pb.Coin.AsObject>,
        removeFeeCreateCommitmentFlatList: Array<cosmos_base_v1beta1_coin_pb.Coin.AsObject>,
        setFeeCommitmentSettlementBips: number,
        unsetFeeCommitmentSettlementBips: boolean,
    }
}

export class MsgGovManageFeesResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgGovManageFeesResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgGovManageFeesResponse): MsgGovManageFeesResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgGovManageFeesResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgGovManageFeesResponse;
    static deserializeBinaryFromReader(message: MsgGovManageFeesResponse, reader: jspb.BinaryReader): MsgGovManageFeesResponse;
}

export namespace MsgGovManageFeesResponse {
    export type AsObject = {
    }
}

export class MsgGovCloseMarketRequest extends jspb.Message { 
    getAuthority(): string;
    setAuthority(value: string): MsgGovCloseMarketRequest;
    getMarketId(): number;
    setMarketId(value: number): MsgGovCloseMarketRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgGovCloseMarketRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgGovCloseMarketRequest): MsgGovCloseMarketRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgGovCloseMarketRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgGovCloseMarketRequest;
    static deserializeBinaryFromReader(message: MsgGovCloseMarketRequest, reader: jspb.BinaryReader): MsgGovCloseMarketRequest;
}

export namespace MsgGovCloseMarketRequest {
    export type AsObject = {
        authority: string,
        marketId: number,
    }
}

export class MsgGovCloseMarketResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgGovCloseMarketResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgGovCloseMarketResponse): MsgGovCloseMarketResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgGovCloseMarketResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgGovCloseMarketResponse;
    static deserializeBinaryFromReader(message: MsgGovCloseMarketResponse, reader: jspb.BinaryReader): MsgGovCloseMarketResponse;
}

export namespace MsgGovCloseMarketResponse {
    export type AsObject = {
    }
}

export class MsgGovUpdateParamsRequest extends jspb.Message { 
    getAuthority(): string;
    setAuthority(value: string): MsgGovUpdateParamsRequest;

    hasParams(): boolean;
    clearParams(): void;
    getParams(): provenance_exchange_v1_params_pb.Params | undefined;
    setParams(value?: provenance_exchange_v1_params_pb.Params): MsgGovUpdateParamsRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgGovUpdateParamsRequest.AsObject;
    static toObject(includeInstance: boolean, msg: MsgGovUpdateParamsRequest): MsgGovUpdateParamsRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgGovUpdateParamsRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgGovUpdateParamsRequest;
    static deserializeBinaryFromReader(message: MsgGovUpdateParamsRequest, reader: jspb.BinaryReader): MsgGovUpdateParamsRequest;
}

export namespace MsgGovUpdateParamsRequest {
    export type AsObject = {
        authority: string,
        params?: provenance_exchange_v1_params_pb.Params.AsObject,
    }
}

export class MsgGovUpdateParamsResponse extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MsgGovUpdateParamsResponse.AsObject;
    static toObject(includeInstance: boolean, msg: MsgGovUpdateParamsResponse): MsgGovUpdateParamsResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MsgGovUpdateParamsResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MsgGovUpdateParamsResponse;
    static deserializeBinaryFromReader(message: MsgGovUpdateParamsResponse, reader: jspb.BinaryReader): MsgGovUpdateParamsResponse;
}

export namespace MsgGovUpdateParamsResponse {
    export type AsObject = {
    }
}