@provenanceio/wallet-utils/esm/proto/provenance/exchange/v1/tx_pb.d.ts

Typescript Utilities for Provenance Blockchain Wallet

// 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>,