@provenanceio/wallet-utils/lib/proto/provenance/exchange/v1/events_pb.d.ts

Typescript Utilities for Provenance Blockchain Wallet

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

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

import * as jspb from "google-protobuf";
import * as cosmos_proto_cosmos_pb from "../../../cosmos_proto/cosmos_pb";

export class EventOrderCreated extends jspb.Message { 
    getOrderId(): number;
    setOrderId(value: number): EventOrderCreated;
    getOrderType(): string;
    setOrderType(value: string): EventOrderCreated;
    getMarketId(): number;
    setMarketId(value: number): EventOrderCreated;
    getExternalId(): string;
    setExternalId(value: string): EventOrderCreated;

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

export namespace EventOrderCreated {
    export type AsObject = {
        orderId: number,
        orderType: string,
        marketId: number,
        externalId: string,
    }
}

export class EventOrderCancelled extends jspb.Message { 
    getOrderId(): number;
    setOrderId(value: number): EventOrderCancelled;
    getCancelledBy(): string;
    setCancelledBy(value: string): EventOrderCancelled;
    getMarketId(): number;
    setMarketId(value: number): EventOrderCancelled;
    getExternalId(): string;
    setExternalId(value: string): EventOrderCancelled;

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

export namespace EventOrderCancelled {
    export type AsObject = {
        orderId: number,
        cancelledBy: string,
        marketId: number,
        externalId: string,
    }
}

export class EventOrderFilled extends jspb.Message { 
    getOrderId(): number;
    setOrderId(value: number): EventOrderFilled;
    getAssets(): string;
    setAssets(value: string): EventOrderFilled;
    getPrice(): string;
    setPrice(value: string): EventOrderFilled;
    getFees(): string;
    setFees(value: string): EventOrderFilled;
    getMarketId(): number;
    setMarketId(value: number): EventOrderFilled;
    getExternalId(): string;
    setExternalId(value: string): EventOrderFilled;

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

export namespace EventOrderFilled {
    export type AsObject = {
        orderId: number,
        assets: string,
        price: string,
        fees: string,
        marketId: number,
        externalId: string,
    }
}

export class EventOrderPartiallyFilled extends jspb.Message { 
    getOrderId(): number;
    setOrderId(value: number): EventOrderPartiallyFilled;
    getAssets(): string;
    setAssets(value: string): EventOrderPartiallyFilled;
    getPrice(): string;
    setPrice(value: string): EventOrderPartiallyFilled;
    getFees(): string;
    setFees(value: string): EventOrderPartiallyFilled;
    getMarketId(): number;
    setMarketId(value: number): EventOrderPartiallyFilled;
    getExternalId(): string;
    setExternalId(value: string): EventOrderPartiallyFilled;

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

export namespace EventOrderPartiallyFilled {
    export type AsObject = {
        orderId: number,
        assets: string,
        price: string,
        fees: string,
        marketId: number,
        externalId: string,
    }
}

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

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

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

export class EventFundsCommitted extends jspb.Message { 
    getAccount(): string;
    setAccount(value: string): EventFundsCommitted;
    getMarketId(): number;
    setMarketId(value: number): EventFundsCommitted;
    getAmount(): string;
    setAmount(value: string): EventFundsCommitted;
    getTag(): string;
    setTag(value: string): EventFundsCommitted;

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

export namespace EventFundsCommitted {
    export type AsObject = {
        account: string,
        marketId: number,
        amount: string,
        tag: string,
    }
}

export class EventCommitmentReleased extends jspb.Message { 
    getAccount(): string;
    setAccount(value: string): EventCommitmentReleased;
    getMarketId(): number;
    setMarketId(value: number): EventCommitmentReleased;
    getAmount(): string;
    setAmount(value: string): EventCommitmentReleased;
    getTag(): string;
    setTag(value: string): EventCommitmentReleased;

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

export namespace EventCommitmentReleased {
    export type AsObject = {
        account: string,
        marketId: number,
        amount: string,
        tag: string,
    }
}

export class EventMarketWithdraw extends jspb.Message { 
    getMarketId(): number;
    setMarketId(value: number): EventMarketWithdraw;
    getAmount(): string;
    setAmount(value: string): EventMarketWithdraw;
    getDestination(): string;
    setDestination(value: string): EventMarketWithdraw;
    getWithdrawnBy(): string;
    setWithdrawnBy(value: string): EventMarketWithdraw;

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

export namespace EventMarketWithdraw {
    export type AsObject = {
        marketId: number,
        amount: string,
        destination: string,
        withdrawnBy: string,
    }
}

export class EventMarketDetailsUpdated extends jspb.Message { 
    getMarketId(): number;
    setMarketId(value: number): EventMarketDetailsUpdated;
    getUpdatedBy(): string;
    setUpdatedBy(value: string): EventMarketDetailsUpdated;

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

export namespace EventMarketDetailsUpdated {
    export type AsObject = {
        marketId: number,
        updatedBy: string,
    }
}

export class EventMarketEnabled extends jspb.Message { 
    getMarketId(): number;
    setMarketId(value: number): EventMarketEnabled;
    getUpdatedBy(): string;
    setUpdatedBy(value: string): EventMarketEnabled;

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

export namespace EventMarketEnabled {
    export type AsObject = {
        marketId: number,
        updatedBy: string,
    }
}

export class EventMarketDisabled extends jspb.Message { 
    getMarketId(): number;
    setMarketId(value: number): EventMarketDisabled;
    getUpdatedBy(): string;
    setUpdatedBy(value: string): EventMarketDisabled;

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

export namespace EventMarketDisabled {
    export type AsObject = {
        marketId: number,
        updatedBy: string,
    }
}

export class EventMarketOrdersEnabled extends jspb.Message { 
    getMarketId(): number;
    setMarketId(value: number): EventMarketOrdersEnabled;
    getUpdatedBy(): string;
    setUpdatedBy(value: string): EventMarketOrdersEnabled;

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

export namespace EventMarketOrdersEnabled {
    export type AsObject = {
        marketId: number,
        updatedBy: string,
    }
}

export class EventMarketOrdersDisabled extends jspb.Message { 
    getMarketId(): number;
    setMarketId(value: number): EventMarketOrdersDisabled;
    getUpdatedBy(): string;
    setUpdatedBy(value: string): EventMarketOrdersDisabled;

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

export namespace EventMarketOrdersDisabled {
    export type AsObject = {
        marketId: number,
        updatedBy: string,
    }
}

export class EventMarketUserSettleEnabled extends jspb.Message { 
    getMarketId(): number;
    setMarketId(value: number): EventMarketUserSettleEnabled;
    getUpdatedBy(): string;
    setUpdatedBy(value: string): EventMarketUserSettleEnabled;

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

export namespace EventMarketUserSettleEnabled {
    export type AsObject = {
        marketId: number,
        updatedBy: string,
    }
}

export class EventMarketUserSettleDisabled extends jspb.Message { 
    getMarketId(): number;
    setMarketId(value: number): EventMarketUserSettleDisabled;
    getUpdatedBy(): string;
    setUpdatedBy(value: string): EventMarketUserSettleDisabled;

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

export namespace EventMarketUserSettleDisabled {
    export type AsObject = {
        marketId: number,
        updatedBy: string,
    }
}

export class EventMarketCommitmentsEnabled extends jspb.Message { 
    getMarketId(): number;
    setMarketId(value: number): EventMarketCommitmentsEnabled;
    getUpdatedBy(): string;
    setUpdatedBy(value: string): EventMarketCommitmentsEnabled;

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

export namespace EventMarketCommitmentsEnabled {
    export type AsObject = {
        marketId: number,
        updatedBy: string,
    }
}

export class EventMarketCommitmentsDisabled extends jspb.Message { 
    getMarketId(): number;
    setMarketId(value: number): EventMarketCommitmentsDisabled;
    getUpdatedBy(): string;
    setUpdatedBy(value: string): EventMarketCommitmentsDisabled;

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

export namespace EventMarketCommitmentsDisabled {
    export type AsObject = {
        marketId: number,
        updatedBy: string,
    }
}

export class EventMarketIntermediaryDenomUpdated extends jspb.Message { 
    getMarketId(): number;
    setMarketId(value: number): EventMarketIntermediaryDenomUpdated;
    getUpdatedBy(): string;
    setUpdatedBy(value: string): EventMarketIntermediaryDenomUpdated;

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

export namespace EventMarketIntermediaryDenomUpdated {
    export type AsObject = {
        marketId: number,
        updatedBy: string,
    }
}

export class EventMarketPermissionsUpdated extends jspb.Message { 
    getMarketId(): number;
    setMarketId(value: number): EventMarketPermissionsUpdated;
    getUpdatedBy(): string;
    setUpdatedBy(value: string): EventMarketPermissionsUpdated;

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

export namespace EventMarketPermissionsUpdated {
    export type AsObject = {
        marketId: number,
        updatedBy: string,
    }
}

export class EventMarketReqAttrUpdated extends jspb.Message { 
    getMarketId(): number;
    setMarketId(value: number): EventMarketReqAttrUpdated;
    getUpdatedBy(): string;
    setUpdatedBy(value: string): EventMarketReqAttrUpdated;

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

export namespace EventMarketReqAttrUpdated {
    export type AsObject = {
        marketId: number,
        updatedBy: string,
    }
}

export class EventMarketCreated extends jspb.Message { 
    getMarketId(): number;
    setMarketId(value: number): EventMarketCreated;

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

export namespace EventMarketCreated {
    export type AsObject = {
        marketId: number,
    }
}

export class EventMarketFeesUpdated extends jspb.Message { 
    getMarketId(): number;
    setMarketId(value: number): EventMarketFeesUpdated;

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

export namespace EventMarketFeesUpdated {
    export type AsObject = {
        marketId: number,
    }
}

export class EventParamsUpdated extends jspb.Message { 

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

export namespace EventParamsUpdated {
    export type AsObject = {
    }
}

export class EventPaymentCreated extends jspb.Message { 
    getSource(): string;
    setSource(value: string): EventPaymentCreated;
    getSourceAmount(): string;
    setSourceAmount(value: string): EventPaymentCreated;
    getTarget(): string;
    setTarget(value: string): EventPaymentCreated;
    getTargetAmount(): string;
    setTargetAmount(value: string): EventPaymentCreated;
    getExternalId(): string;
    setExternalId(value: string): EventPaymentCreated;

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

export namespace EventPaymentCreated {
    export type AsObject = {
        source: string,
        sourceAmount: string,
        target: string,
        targetAmount: string,
        externalId: string,
    }
}

export class EventPaymentUpdated extends jspb.Message { 
    getSource(): string;
    setSource(value: string): EventPaymentUpdated;
    getSourceAmount(): string;
    setSourceAmount(value: string): EventPaymentUpdated;
    getOldTarget(): string;
    setOldTarget(value: string): EventPaymentUpdated;
    getNewTarget(): string;
    setNewTarget(value: string): EventPaymentUpdated;
    getTargetAmount(): string;
    setTargetAmount(value: string): EventPaymentUpdated;
    getExternalId(): string;
    setExternalId(value: string): EventPaymentUpdated;

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

export namespace EventPaymentUpdated {
    export type AsObject = {
        source: string,
        sourceAmount: string,
        oldTarget: string,
        newTarget: string,
        targetAmount: string,
        externalId: string,
    }
}

export class EventPaymentAccepted extends jspb.Message { 
    getSource(): string;
    setSource(value: string): EventPaymentAccepted;
    getSourceAmount(): string;
    setSourceAmount(value: string): EventPaymentAccepted;
    getTarget(): string;
    setTarget(value: string): EventPaymentAccepted;
    getTargetAmount(): string;
    setTargetAmount(value: string): EventPaymentAccepted;
    getExternalId(): string;
    setExternalId(value: string): EventPaymentAccepted;

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

export namespace EventPaymentAccepted {
    export type AsObject = {
        source: string,
        sourceAmount: string,
        target: string,
        targetAmount: string,
        externalId: string,
    }
}

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

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

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

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

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

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