mirror of
https://github.com/haveno-dex/haveno-ts.git
synced 2024-12-14 10:14:25 -05:00
8425 lines
315 KiB
TypeScript
8425 lines
315 KiB
TypeScript
import * as jspb from 'google-protobuf'
|
|
|
|
|
|
|
|
export class NetworkEnvelope extends jspb.Message {
|
|
getMessageVersion(): string;
|
|
setMessageVersion(value: string): NetworkEnvelope;
|
|
|
|
getPreliminaryGetDataRequest(): PreliminaryGetDataRequest | undefined;
|
|
setPreliminaryGetDataRequest(value?: PreliminaryGetDataRequest): NetworkEnvelope;
|
|
hasPreliminaryGetDataRequest(): boolean;
|
|
clearPreliminaryGetDataRequest(): NetworkEnvelope;
|
|
|
|
getGetDataResponse(): GetDataResponse | undefined;
|
|
setGetDataResponse(value?: GetDataResponse): NetworkEnvelope;
|
|
hasGetDataResponse(): boolean;
|
|
clearGetDataResponse(): NetworkEnvelope;
|
|
|
|
getGetUpdatedDataRequest(): GetUpdatedDataRequest | undefined;
|
|
setGetUpdatedDataRequest(value?: GetUpdatedDataRequest): NetworkEnvelope;
|
|
hasGetUpdatedDataRequest(): boolean;
|
|
clearGetUpdatedDataRequest(): NetworkEnvelope;
|
|
|
|
getGetPeersRequest(): GetPeersRequest | undefined;
|
|
setGetPeersRequest(value?: GetPeersRequest): NetworkEnvelope;
|
|
hasGetPeersRequest(): boolean;
|
|
clearGetPeersRequest(): NetworkEnvelope;
|
|
|
|
getGetPeersResponse(): GetPeersResponse | undefined;
|
|
setGetPeersResponse(value?: GetPeersResponse): NetworkEnvelope;
|
|
hasGetPeersResponse(): boolean;
|
|
clearGetPeersResponse(): NetworkEnvelope;
|
|
|
|
getPing(): Ping | undefined;
|
|
setPing(value?: Ping): NetworkEnvelope;
|
|
hasPing(): boolean;
|
|
clearPing(): NetworkEnvelope;
|
|
|
|
getPong(): Pong | undefined;
|
|
setPong(value?: Pong): NetworkEnvelope;
|
|
hasPong(): boolean;
|
|
clearPong(): NetworkEnvelope;
|
|
|
|
getOfferAvailabilityRequest(): OfferAvailabilityRequest | undefined;
|
|
setOfferAvailabilityRequest(value?: OfferAvailabilityRequest): NetworkEnvelope;
|
|
hasOfferAvailabilityRequest(): boolean;
|
|
clearOfferAvailabilityRequest(): NetworkEnvelope;
|
|
|
|
getOfferAvailabilityResponse(): OfferAvailabilityResponse | undefined;
|
|
setOfferAvailabilityResponse(value?: OfferAvailabilityResponse): NetworkEnvelope;
|
|
hasOfferAvailabilityResponse(): boolean;
|
|
clearOfferAvailabilityResponse(): NetworkEnvelope;
|
|
|
|
getRefreshOfferMessage(): RefreshOfferMessage | undefined;
|
|
setRefreshOfferMessage(value?: RefreshOfferMessage): NetworkEnvelope;
|
|
hasRefreshOfferMessage(): boolean;
|
|
clearRefreshOfferMessage(): NetworkEnvelope;
|
|
|
|
getAddDataMessage(): AddDataMessage | undefined;
|
|
setAddDataMessage(value?: AddDataMessage): NetworkEnvelope;
|
|
hasAddDataMessage(): boolean;
|
|
clearAddDataMessage(): NetworkEnvelope;
|
|
|
|
getRemoveDataMessage(): RemoveDataMessage | undefined;
|
|
setRemoveDataMessage(value?: RemoveDataMessage): NetworkEnvelope;
|
|
hasRemoveDataMessage(): boolean;
|
|
clearRemoveDataMessage(): NetworkEnvelope;
|
|
|
|
getRemoveMailboxDataMessage(): RemoveMailboxDataMessage | undefined;
|
|
setRemoveMailboxDataMessage(value?: RemoveMailboxDataMessage): NetworkEnvelope;
|
|
hasRemoveMailboxDataMessage(): boolean;
|
|
clearRemoveMailboxDataMessage(): NetworkEnvelope;
|
|
|
|
getCloseConnectionMessage(): CloseConnectionMessage | undefined;
|
|
setCloseConnectionMessage(value?: CloseConnectionMessage): NetworkEnvelope;
|
|
hasCloseConnectionMessage(): boolean;
|
|
clearCloseConnectionMessage(): NetworkEnvelope;
|
|
|
|
getPrefixedSealedAndSignedMessage(): PrefixedSealedAndSignedMessage | undefined;
|
|
setPrefixedSealedAndSignedMessage(value?: PrefixedSealedAndSignedMessage): NetworkEnvelope;
|
|
hasPrefixedSealedAndSignedMessage(): boolean;
|
|
clearPrefixedSealedAndSignedMessage(): NetworkEnvelope;
|
|
|
|
getInputsForDepositTxRequest(): InputsForDepositTxRequest | undefined;
|
|
setInputsForDepositTxRequest(value?: InputsForDepositTxRequest): NetworkEnvelope;
|
|
hasInputsForDepositTxRequest(): boolean;
|
|
clearInputsForDepositTxRequest(): NetworkEnvelope;
|
|
|
|
getInputsForDepositTxResponse(): InputsForDepositTxResponse | undefined;
|
|
setInputsForDepositTxResponse(value?: InputsForDepositTxResponse): NetworkEnvelope;
|
|
hasInputsForDepositTxResponse(): boolean;
|
|
clearInputsForDepositTxResponse(): NetworkEnvelope;
|
|
|
|
getDepositTxMessage(): DepositTxMessage | undefined;
|
|
setDepositTxMessage(value?: DepositTxMessage): NetworkEnvelope;
|
|
hasDepositTxMessage(): boolean;
|
|
clearDepositTxMessage(): NetworkEnvelope;
|
|
|
|
getDisputeOpenedMessage(): DisputeOpenedMessage | undefined;
|
|
setDisputeOpenedMessage(value?: DisputeOpenedMessage): NetworkEnvelope;
|
|
hasDisputeOpenedMessage(): boolean;
|
|
clearDisputeOpenedMessage(): NetworkEnvelope;
|
|
|
|
getDisputeClosedMessage(): DisputeClosedMessage | undefined;
|
|
setDisputeClosedMessage(value?: DisputeClosedMessage): NetworkEnvelope;
|
|
hasDisputeClosedMessage(): boolean;
|
|
clearDisputeClosedMessage(): NetworkEnvelope;
|
|
|
|
getChatMessage(): ChatMessage | undefined;
|
|
setChatMessage(value?: ChatMessage): NetworkEnvelope;
|
|
hasChatMessage(): boolean;
|
|
clearChatMessage(): NetworkEnvelope;
|
|
|
|
getPrivateNotificationMessage(): PrivateNotificationMessage | undefined;
|
|
setPrivateNotificationMessage(value?: PrivateNotificationMessage): NetworkEnvelope;
|
|
hasPrivateNotificationMessage(): boolean;
|
|
clearPrivateNotificationMessage(): NetworkEnvelope;
|
|
|
|
getAddPersistableNetworkPayloadMessage(): AddPersistableNetworkPayloadMessage | undefined;
|
|
setAddPersistableNetworkPayloadMessage(value?: AddPersistableNetworkPayloadMessage): NetworkEnvelope;
|
|
hasAddPersistableNetworkPayloadMessage(): boolean;
|
|
clearAddPersistableNetworkPayloadMessage(): NetworkEnvelope;
|
|
|
|
getAckMessage(): AckMessage | undefined;
|
|
setAckMessage(value?: AckMessage): NetworkEnvelope;
|
|
hasAckMessage(): boolean;
|
|
clearAckMessage(): NetworkEnvelope;
|
|
|
|
getBundleOfEnvelopes(): BundleOfEnvelopes | undefined;
|
|
setBundleOfEnvelopes(value?: BundleOfEnvelopes): NetworkEnvelope;
|
|
hasBundleOfEnvelopes(): boolean;
|
|
clearBundleOfEnvelopes(): NetworkEnvelope;
|
|
|
|
getMediatedPayoutTxSignatureMessage(): MediatedPayoutTxSignatureMessage | undefined;
|
|
setMediatedPayoutTxSignatureMessage(value?: MediatedPayoutTxSignatureMessage): NetworkEnvelope;
|
|
hasMediatedPayoutTxSignatureMessage(): boolean;
|
|
clearMediatedPayoutTxSignatureMessage(): NetworkEnvelope;
|
|
|
|
getMediatedPayoutTxPublishedMessage(): MediatedPayoutTxPublishedMessage | undefined;
|
|
setMediatedPayoutTxPublishedMessage(value?: MediatedPayoutTxPublishedMessage): NetworkEnvelope;
|
|
hasMediatedPayoutTxPublishedMessage(): boolean;
|
|
clearMediatedPayoutTxPublishedMessage(): NetworkEnvelope;
|
|
|
|
getDelayedPayoutTxSignatureRequest(): DelayedPayoutTxSignatureRequest | undefined;
|
|
setDelayedPayoutTxSignatureRequest(value?: DelayedPayoutTxSignatureRequest): NetworkEnvelope;
|
|
hasDelayedPayoutTxSignatureRequest(): boolean;
|
|
clearDelayedPayoutTxSignatureRequest(): NetworkEnvelope;
|
|
|
|
getDelayedPayoutTxSignatureResponse(): DelayedPayoutTxSignatureResponse | undefined;
|
|
setDelayedPayoutTxSignatureResponse(value?: DelayedPayoutTxSignatureResponse): NetworkEnvelope;
|
|
hasDelayedPayoutTxSignatureResponse(): boolean;
|
|
clearDelayedPayoutTxSignatureResponse(): NetworkEnvelope;
|
|
|
|
getDepositTxAndDelayedPayoutTxMessage(): DepositTxAndDelayedPayoutTxMessage | undefined;
|
|
setDepositTxAndDelayedPayoutTxMessage(value?: DepositTxAndDelayedPayoutTxMessage): NetworkEnvelope;
|
|
hasDepositTxAndDelayedPayoutTxMessage(): boolean;
|
|
clearDepositTxAndDelayedPayoutTxMessage(): NetworkEnvelope;
|
|
|
|
getPeerPublishedDelayedPayoutTxMessage(): PeerPublishedDelayedPayoutTxMessage | undefined;
|
|
setPeerPublishedDelayedPayoutTxMessage(value?: PeerPublishedDelayedPayoutTxMessage): NetworkEnvelope;
|
|
hasPeerPublishedDelayedPayoutTxMessage(): boolean;
|
|
clearPeerPublishedDelayedPayoutTxMessage(): NetworkEnvelope;
|
|
|
|
getRefreshTradeStateRequest(): RefreshTradeStateRequest | undefined;
|
|
setRefreshTradeStateRequest(value?: RefreshTradeStateRequest): NetworkEnvelope;
|
|
hasRefreshTradeStateRequest(): boolean;
|
|
clearRefreshTradeStateRequest(): NetworkEnvelope;
|
|
|
|
getGetInventoryRequest(): GetInventoryRequest | undefined;
|
|
setGetInventoryRequest(value?: GetInventoryRequest): NetworkEnvelope;
|
|
hasGetInventoryRequest(): boolean;
|
|
clearGetInventoryRequest(): NetworkEnvelope;
|
|
|
|
getGetInventoryResponse(): GetInventoryResponse | undefined;
|
|
setGetInventoryResponse(value?: GetInventoryResponse): NetworkEnvelope;
|
|
hasGetInventoryResponse(): boolean;
|
|
clearGetInventoryResponse(): NetworkEnvelope;
|
|
|
|
getSignOfferRequest(): SignOfferRequest | undefined;
|
|
setSignOfferRequest(value?: SignOfferRequest): NetworkEnvelope;
|
|
hasSignOfferRequest(): boolean;
|
|
clearSignOfferRequest(): NetworkEnvelope;
|
|
|
|
getSignOfferResponse(): SignOfferResponse | undefined;
|
|
setSignOfferResponse(value?: SignOfferResponse): NetworkEnvelope;
|
|
hasSignOfferResponse(): boolean;
|
|
clearSignOfferResponse(): NetworkEnvelope;
|
|
|
|
getInitTradeRequest(): InitTradeRequest | undefined;
|
|
setInitTradeRequest(value?: InitTradeRequest): NetworkEnvelope;
|
|
hasInitTradeRequest(): boolean;
|
|
clearInitTradeRequest(): NetworkEnvelope;
|
|
|
|
getInitMultisigRequest(): InitMultisigRequest | undefined;
|
|
setInitMultisigRequest(value?: InitMultisigRequest): NetworkEnvelope;
|
|
hasInitMultisigRequest(): boolean;
|
|
clearInitMultisigRequest(): NetworkEnvelope;
|
|
|
|
getSignContractRequest(): SignContractRequest | undefined;
|
|
setSignContractRequest(value?: SignContractRequest): NetworkEnvelope;
|
|
hasSignContractRequest(): boolean;
|
|
clearSignContractRequest(): NetworkEnvelope;
|
|
|
|
getSignContractResponse(): SignContractResponse | undefined;
|
|
setSignContractResponse(value?: SignContractResponse): NetworkEnvelope;
|
|
hasSignContractResponse(): boolean;
|
|
clearSignContractResponse(): NetworkEnvelope;
|
|
|
|
getDepositRequest(): DepositRequest | undefined;
|
|
setDepositRequest(value?: DepositRequest): NetworkEnvelope;
|
|
hasDepositRequest(): boolean;
|
|
clearDepositRequest(): NetworkEnvelope;
|
|
|
|
getDepositResponse(): DepositResponse | undefined;
|
|
setDepositResponse(value?: DepositResponse): NetworkEnvelope;
|
|
hasDepositResponse(): boolean;
|
|
clearDepositResponse(): NetworkEnvelope;
|
|
|
|
getDepositsConfirmedMessage(): DepositsConfirmedMessage | undefined;
|
|
setDepositsConfirmedMessage(value?: DepositsConfirmedMessage): NetworkEnvelope;
|
|
hasDepositsConfirmedMessage(): boolean;
|
|
clearDepositsConfirmedMessage(): NetworkEnvelope;
|
|
|
|
getPaymentSentMessage(): PaymentSentMessage | undefined;
|
|
setPaymentSentMessage(value?: PaymentSentMessage): NetworkEnvelope;
|
|
hasPaymentSentMessage(): boolean;
|
|
clearPaymentSentMessage(): NetworkEnvelope;
|
|
|
|
getPaymentReceivedMessage(): PaymentReceivedMessage | undefined;
|
|
setPaymentReceivedMessage(value?: PaymentReceivedMessage): NetworkEnvelope;
|
|
hasPaymentReceivedMessage(): boolean;
|
|
clearPaymentReceivedMessage(): NetworkEnvelope;
|
|
|
|
getMessageCase(): NetworkEnvelope.MessageCase;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): NetworkEnvelope.AsObject;
|
|
static toObject(includeInstance: boolean, msg: NetworkEnvelope): NetworkEnvelope.AsObject;
|
|
static serializeBinaryToWriter(message: NetworkEnvelope, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): NetworkEnvelope;
|
|
static deserializeBinaryFromReader(message: NetworkEnvelope, reader: jspb.BinaryReader): NetworkEnvelope;
|
|
}
|
|
|
|
export namespace NetworkEnvelope {
|
|
export type AsObject = {
|
|
messageVersion: string,
|
|
preliminaryGetDataRequest?: PreliminaryGetDataRequest.AsObject,
|
|
getDataResponse?: GetDataResponse.AsObject,
|
|
getUpdatedDataRequest?: GetUpdatedDataRequest.AsObject,
|
|
getPeersRequest?: GetPeersRequest.AsObject,
|
|
getPeersResponse?: GetPeersResponse.AsObject,
|
|
ping?: Ping.AsObject,
|
|
pong?: Pong.AsObject,
|
|
offerAvailabilityRequest?: OfferAvailabilityRequest.AsObject,
|
|
offerAvailabilityResponse?: OfferAvailabilityResponse.AsObject,
|
|
refreshOfferMessage?: RefreshOfferMessage.AsObject,
|
|
addDataMessage?: AddDataMessage.AsObject,
|
|
removeDataMessage?: RemoveDataMessage.AsObject,
|
|
removeMailboxDataMessage?: RemoveMailboxDataMessage.AsObject,
|
|
closeConnectionMessage?: CloseConnectionMessage.AsObject,
|
|
prefixedSealedAndSignedMessage?: PrefixedSealedAndSignedMessage.AsObject,
|
|
inputsForDepositTxRequest?: InputsForDepositTxRequest.AsObject,
|
|
inputsForDepositTxResponse?: InputsForDepositTxResponse.AsObject,
|
|
depositTxMessage?: DepositTxMessage.AsObject,
|
|
disputeOpenedMessage?: DisputeOpenedMessage.AsObject,
|
|
disputeClosedMessage?: DisputeClosedMessage.AsObject,
|
|
chatMessage?: ChatMessage.AsObject,
|
|
privateNotificationMessage?: PrivateNotificationMessage.AsObject,
|
|
addPersistableNetworkPayloadMessage?: AddPersistableNetworkPayloadMessage.AsObject,
|
|
ackMessage?: AckMessage.AsObject,
|
|
bundleOfEnvelopes?: BundleOfEnvelopes.AsObject,
|
|
mediatedPayoutTxSignatureMessage?: MediatedPayoutTxSignatureMessage.AsObject,
|
|
mediatedPayoutTxPublishedMessage?: MediatedPayoutTxPublishedMessage.AsObject,
|
|
delayedPayoutTxSignatureRequest?: DelayedPayoutTxSignatureRequest.AsObject,
|
|
delayedPayoutTxSignatureResponse?: DelayedPayoutTxSignatureResponse.AsObject,
|
|
depositTxAndDelayedPayoutTxMessage?: DepositTxAndDelayedPayoutTxMessage.AsObject,
|
|
peerPublishedDelayedPayoutTxMessage?: PeerPublishedDelayedPayoutTxMessage.AsObject,
|
|
refreshTradeStateRequest?: RefreshTradeStateRequest.AsObject,
|
|
getInventoryRequest?: GetInventoryRequest.AsObject,
|
|
getInventoryResponse?: GetInventoryResponse.AsObject,
|
|
signOfferRequest?: SignOfferRequest.AsObject,
|
|
signOfferResponse?: SignOfferResponse.AsObject,
|
|
initTradeRequest?: InitTradeRequest.AsObject,
|
|
initMultisigRequest?: InitMultisigRequest.AsObject,
|
|
signContractRequest?: SignContractRequest.AsObject,
|
|
signContractResponse?: SignContractResponse.AsObject,
|
|
depositRequest?: DepositRequest.AsObject,
|
|
depositResponse?: DepositResponse.AsObject,
|
|
depositsConfirmedMessage?: DepositsConfirmedMessage.AsObject,
|
|
paymentSentMessage?: PaymentSentMessage.AsObject,
|
|
paymentReceivedMessage?: PaymentReceivedMessage.AsObject,
|
|
}
|
|
|
|
export enum MessageCase {
|
|
MESSAGE_NOT_SET = 0,
|
|
PRELIMINARY_GET_DATA_REQUEST = 2,
|
|
GET_DATA_RESPONSE = 3,
|
|
GET_UPDATED_DATA_REQUEST = 4,
|
|
GET_PEERS_REQUEST = 5,
|
|
GET_PEERS_RESPONSE = 6,
|
|
PING = 7,
|
|
PONG = 8,
|
|
OFFER_AVAILABILITY_REQUEST = 9,
|
|
OFFER_AVAILABILITY_RESPONSE = 10,
|
|
REFRESH_OFFER_MESSAGE = 11,
|
|
ADD_DATA_MESSAGE = 12,
|
|
REMOVE_DATA_MESSAGE = 13,
|
|
REMOVE_MAILBOX_DATA_MESSAGE = 14,
|
|
CLOSE_CONNECTION_MESSAGE = 15,
|
|
PREFIXED_SEALED_AND_SIGNED_MESSAGE = 16,
|
|
INPUTS_FOR_DEPOSIT_TX_REQUEST = 17,
|
|
INPUTS_FOR_DEPOSIT_TX_RESPONSE = 18,
|
|
DEPOSIT_TX_MESSAGE = 19,
|
|
DISPUTE_OPENED_MESSAGE = 20,
|
|
DISPUTE_CLOSED_MESSAGE = 21,
|
|
CHAT_MESSAGE = 22,
|
|
PRIVATE_NOTIFICATION_MESSAGE = 23,
|
|
ADD_PERSISTABLE_NETWORK_PAYLOAD_MESSAGE = 24,
|
|
ACK_MESSAGE = 25,
|
|
BUNDLE_OF_ENVELOPES = 26,
|
|
MEDIATED_PAYOUT_TX_SIGNATURE_MESSAGE = 27,
|
|
MEDIATED_PAYOUT_TX_PUBLISHED_MESSAGE = 28,
|
|
DELAYED_PAYOUT_TX_SIGNATURE_REQUEST = 29,
|
|
DELAYED_PAYOUT_TX_SIGNATURE_RESPONSE = 30,
|
|
DEPOSIT_TX_AND_DELAYED_PAYOUT_TX_MESSAGE = 31,
|
|
PEER_PUBLISHED_DELAYED_PAYOUT_TX_MESSAGE = 32,
|
|
REFRESH_TRADE_STATE_REQUEST = 33,
|
|
GET_INVENTORY_REQUEST = 35,
|
|
GET_INVENTORY_RESPONSE = 36,
|
|
SIGN_OFFER_REQUEST = 1001,
|
|
SIGN_OFFER_RESPONSE = 1002,
|
|
INIT_TRADE_REQUEST = 1003,
|
|
INIT_MULTISIG_REQUEST = 1004,
|
|
SIGN_CONTRACT_REQUEST = 1005,
|
|
SIGN_CONTRACT_RESPONSE = 1006,
|
|
DEPOSIT_REQUEST = 1007,
|
|
DEPOSIT_RESPONSE = 1008,
|
|
DEPOSITS_CONFIRMED_MESSAGE = 1009,
|
|
PAYMENT_SENT_MESSAGE = 1010,
|
|
PAYMENT_RECEIVED_MESSAGE = 1011,
|
|
}
|
|
}
|
|
|
|
export class BundleOfEnvelopes extends jspb.Message {
|
|
getEnvelopesList(): Array<NetworkEnvelope>;
|
|
setEnvelopesList(value: Array<NetworkEnvelope>): BundleOfEnvelopes;
|
|
clearEnvelopesList(): BundleOfEnvelopes;
|
|
addEnvelopes(value?: NetworkEnvelope, index?: number): NetworkEnvelope;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): BundleOfEnvelopes.AsObject;
|
|
static toObject(includeInstance: boolean, msg: BundleOfEnvelopes): BundleOfEnvelopes.AsObject;
|
|
static serializeBinaryToWriter(message: BundleOfEnvelopes, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): BundleOfEnvelopes;
|
|
static deserializeBinaryFromReader(message: BundleOfEnvelopes, reader: jspb.BinaryReader): BundleOfEnvelopes;
|
|
}
|
|
|
|
export namespace BundleOfEnvelopes {
|
|
export type AsObject = {
|
|
envelopesList: Array<NetworkEnvelope.AsObject>,
|
|
}
|
|
}
|
|
|
|
export class PreliminaryGetDataRequest extends jspb.Message {
|
|
getNonce(): number;
|
|
setNonce(value: number): PreliminaryGetDataRequest;
|
|
|
|
getExcludedKeysList(): Array<Uint8Array | string>;
|
|
setExcludedKeysList(value: Array<Uint8Array | string>): PreliminaryGetDataRequest;
|
|
clearExcludedKeysList(): PreliminaryGetDataRequest;
|
|
addExcludedKeys(value: Uint8Array | string, index?: number): PreliminaryGetDataRequest;
|
|
|
|
getSupportedCapabilitiesList(): Array<number>;
|
|
setSupportedCapabilitiesList(value: Array<number>): PreliminaryGetDataRequest;
|
|
clearSupportedCapabilitiesList(): PreliminaryGetDataRequest;
|
|
addSupportedCapabilities(value: number, index?: number): PreliminaryGetDataRequest;
|
|
|
|
getVersion(): string;
|
|
setVersion(value: string): PreliminaryGetDataRequest;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PreliminaryGetDataRequest.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PreliminaryGetDataRequest): PreliminaryGetDataRequest.AsObject;
|
|
static serializeBinaryToWriter(message: PreliminaryGetDataRequest, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PreliminaryGetDataRequest;
|
|
static deserializeBinaryFromReader(message: PreliminaryGetDataRequest, reader: jspb.BinaryReader): PreliminaryGetDataRequest;
|
|
}
|
|
|
|
export namespace PreliminaryGetDataRequest {
|
|
export type AsObject = {
|
|
nonce: number,
|
|
excludedKeysList: Array<Uint8Array | string>,
|
|
supportedCapabilitiesList: Array<number>,
|
|
version: string,
|
|
}
|
|
}
|
|
|
|
export class GetDataResponse extends jspb.Message {
|
|
getRequestNonce(): number;
|
|
setRequestNonce(value: number): GetDataResponse;
|
|
|
|
getIsGetUpdatedDataResponse(): boolean;
|
|
setIsGetUpdatedDataResponse(value: boolean): GetDataResponse;
|
|
|
|
getDataSetList(): Array<StorageEntryWrapper>;
|
|
setDataSetList(value: Array<StorageEntryWrapper>): GetDataResponse;
|
|
clearDataSetList(): GetDataResponse;
|
|
addDataSet(value?: StorageEntryWrapper, index?: number): StorageEntryWrapper;
|
|
|
|
getSupportedCapabilitiesList(): Array<number>;
|
|
setSupportedCapabilitiesList(value: Array<number>): GetDataResponse;
|
|
clearSupportedCapabilitiesList(): GetDataResponse;
|
|
addSupportedCapabilities(value: number, index?: number): GetDataResponse;
|
|
|
|
getPersistableNetworkPayloadItemsList(): Array<PersistableNetworkPayload>;
|
|
setPersistableNetworkPayloadItemsList(value: Array<PersistableNetworkPayload>): GetDataResponse;
|
|
clearPersistableNetworkPayloadItemsList(): GetDataResponse;
|
|
addPersistableNetworkPayloadItems(value?: PersistableNetworkPayload, index?: number): PersistableNetworkPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): GetDataResponse.AsObject;
|
|
static toObject(includeInstance: boolean, msg: GetDataResponse): GetDataResponse.AsObject;
|
|
static serializeBinaryToWriter(message: GetDataResponse, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): GetDataResponse;
|
|
static deserializeBinaryFromReader(message: GetDataResponse, reader: jspb.BinaryReader): GetDataResponse;
|
|
}
|
|
|
|
export namespace GetDataResponse {
|
|
export type AsObject = {
|
|
requestNonce: number,
|
|
isGetUpdatedDataResponse: boolean,
|
|
dataSetList: Array<StorageEntryWrapper.AsObject>,
|
|
supportedCapabilitiesList: Array<number>,
|
|
persistableNetworkPayloadItemsList: Array<PersistableNetworkPayload.AsObject>,
|
|
}
|
|
}
|
|
|
|
export class GetUpdatedDataRequest extends jspb.Message {
|
|
getSenderNodeAddress(): NodeAddress | undefined;
|
|
setSenderNodeAddress(value?: NodeAddress): GetUpdatedDataRequest;
|
|
hasSenderNodeAddress(): boolean;
|
|
clearSenderNodeAddress(): GetUpdatedDataRequest;
|
|
|
|
getNonce(): number;
|
|
setNonce(value: number): GetUpdatedDataRequest;
|
|
|
|
getExcludedKeysList(): Array<Uint8Array | string>;
|
|
setExcludedKeysList(value: Array<Uint8Array | string>): GetUpdatedDataRequest;
|
|
clearExcludedKeysList(): GetUpdatedDataRequest;
|
|
addExcludedKeys(value: Uint8Array | string, index?: number): GetUpdatedDataRequest;
|
|
|
|
getVersion(): string;
|
|
setVersion(value: string): GetUpdatedDataRequest;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): GetUpdatedDataRequest.AsObject;
|
|
static toObject(includeInstance: boolean, msg: GetUpdatedDataRequest): GetUpdatedDataRequest.AsObject;
|
|
static serializeBinaryToWriter(message: GetUpdatedDataRequest, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): GetUpdatedDataRequest;
|
|
static deserializeBinaryFromReader(message: GetUpdatedDataRequest, reader: jspb.BinaryReader): GetUpdatedDataRequest;
|
|
}
|
|
|
|
export namespace GetUpdatedDataRequest {
|
|
export type AsObject = {
|
|
senderNodeAddress?: NodeAddress.AsObject,
|
|
nonce: number,
|
|
excludedKeysList: Array<Uint8Array | string>,
|
|
version: string,
|
|
}
|
|
}
|
|
|
|
export class GetPeersRequest extends jspb.Message {
|
|
getSenderNodeAddress(): NodeAddress | undefined;
|
|
setSenderNodeAddress(value?: NodeAddress): GetPeersRequest;
|
|
hasSenderNodeAddress(): boolean;
|
|
clearSenderNodeAddress(): GetPeersRequest;
|
|
|
|
getNonce(): number;
|
|
setNonce(value: number): GetPeersRequest;
|
|
|
|
getSupportedCapabilitiesList(): Array<number>;
|
|
setSupportedCapabilitiesList(value: Array<number>): GetPeersRequest;
|
|
clearSupportedCapabilitiesList(): GetPeersRequest;
|
|
addSupportedCapabilities(value: number, index?: number): GetPeersRequest;
|
|
|
|
getReportedPeersList(): Array<Peer>;
|
|
setReportedPeersList(value: Array<Peer>): GetPeersRequest;
|
|
clearReportedPeersList(): GetPeersRequest;
|
|
addReportedPeers(value?: Peer, index?: number): Peer;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): GetPeersRequest.AsObject;
|
|
static toObject(includeInstance: boolean, msg: GetPeersRequest): GetPeersRequest.AsObject;
|
|
static serializeBinaryToWriter(message: GetPeersRequest, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): GetPeersRequest;
|
|
static deserializeBinaryFromReader(message: GetPeersRequest, reader: jspb.BinaryReader): GetPeersRequest;
|
|
}
|
|
|
|
export namespace GetPeersRequest {
|
|
export type AsObject = {
|
|
senderNodeAddress?: NodeAddress.AsObject,
|
|
nonce: number,
|
|
supportedCapabilitiesList: Array<number>,
|
|
reportedPeersList: Array<Peer.AsObject>,
|
|
}
|
|
}
|
|
|
|
export class GetPeersResponse extends jspb.Message {
|
|
getRequestNonce(): number;
|
|
setRequestNonce(value: number): GetPeersResponse;
|
|
|
|
getReportedPeersList(): Array<Peer>;
|
|
setReportedPeersList(value: Array<Peer>): GetPeersResponse;
|
|
clearReportedPeersList(): GetPeersResponse;
|
|
addReportedPeers(value?: Peer, index?: number): Peer;
|
|
|
|
getSupportedCapabilitiesList(): Array<number>;
|
|
setSupportedCapabilitiesList(value: Array<number>): GetPeersResponse;
|
|
clearSupportedCapabilitiesList(): GetPeersResponse;
|
|
addSupportedCapabilities(value: number, index?: number): GetPeersResponse;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): GetPeersResponse.AsObject;
|
|
static toObject(includeInstance: boolean, msg: GetPeersResponse): GetPeersResponse.AsObject;
|
|
static serializeBinaryToWriter(message: GetPeersResponse, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): GetPeersResponse;
|
|
static deserializeBinaryFromReader(message: GetPeersResponse, reader: jspb.BinaryReader): GetPeersResponse;
|
|
}
|
|
|
|
export namespace GetPeersResponse {
|
|
export type AsObject = {
|
|
requestNonce: number,
|
|
reportedPeersList: Array<Peer.AsObject>,
|
|
supportedCapabilitiesList: Array<number>,
|
|
}
|
|
}
|
|
|
|
export class Ping extends jspb.Message {
|
|
getNonce(): number;
|
|
setNonce(value: number): Ping;
|
|
|
|
getLastRoundTripTime(): number;
|
|
setLastRoundTripTime(value: number): Ping;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): Ping.AsObject;
|
|
static toObject(includeInstance: boolean, msg: Ping): Ping.AsObject;
|
|
static serializeBinaryToWriter(message: Ping, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): Ping;
|
|
static deserializeBinaryFromReader(message: Ping, reader: jspb.BinaryReader): Ping;
|
|
}
|
|
|
|
export namespace Ping {
|
|
export type AsObject = {
|
|
nonce: number,
|
|
lastRoundTripTime: number,
|
|
}
|
|
}
|
|
|
|
export class Pong extends jspb.Message {
|
|
getRequestNonce(): number;
|
|
setRequestNonce(value: number): Pong;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): Pong.AsObject;
|
|
static toObject(includeInstance: boolean, msg: Pong): Pong.AsObject;
|
|
static serializeBinaryToWriter(message: Pong, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): Pong;
|
|
static deserializeBinaryFromReader(message: Pong, reader: jspb.BinaryReader): Pong;
|
|
}
|
|
|
|
export namespace Pong {
|
|
export type AsObject = {
|
|
requestNonce: number,
|
|
}
|
|
}
|
|
|
|
export class GetInventoryRequest extends jspb.Message {
|
|
getVersion(): string;
|
|
setVersion(value: string): GetInventoryRequest;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): GetInventoryRequest.AsObject;
|
|
static toObject(includeInstance: boolean, msg: GetInventoryRequest): GetInventoryRequest.AsObject;
|
|
static serializeBinaryToWriter(message: GetInventoryRequest, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): GetInventoryRequest;
|
|
static deserializeBinaryFromReader(message: GetInventoryRequest, reader: jspb.BinaryReader): GetInventoryRequest;
|
|
}
|
|
|
|
export namespace GetInventoryRequest {
|
|
export type AsObject = {
|
|
version: string,
|
|
}
|
|
}
|
|
|
|
export class GetInventoryResponse extends jspb.Message {
|
|
getInventoryMap(): jspb.Map<string, string>;
|
|
clearInventoryMap(): GetInventoryResponse;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): GetInventoryResponse.AsObject;
|
|
static toObject(includeInstance: boolean, msg: GetInventoryResponse): GetInventoryResponse.AsObject;
|
|
static serializeBinaryToWriter(message: GetInventoryResponse, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): GetInventoryResponse;
|
|
static deserializeBinaryFromReader(message: GetInventoryResponse, reader: jspb.BinaryReader): GetInventoryResponse;
|
|
}
|
|
|
|
export namespace GetInventoryResponse {
|
|
export type AsObject = {
|
|
inventoryMap: Array<[string, string]>,
|
|
}
|
|
}
|
|
|
|
export class SignOfferRequest extends jspb.Message {
|
|
getOfferId(): string;
|
|
setOfferId(value: string): SignOfferRequest;
|
|
|
|
getSenderNodeAddress(): NodeAddress | undefined;
|
|
setSenderNodeAddress(value?: NodeAddress): SignOfferRequest;
|
|
hasSenderNodeAddress(): boolean;
|
|
clearSenderNodeAddress(): SignOfferRequest;
|
|
|
|
getPubKeyRing(): PubKeyRing | undefined;
|
|
setPubKeyRing(value?: PubKeyRing): SignOfferRequest;
|
|
hasPubKeyRing(): boolean;
|
|
clearPubKeyRing(): SignOfferRequest;
|
|
|
|
getSenderAccountId(): string;
|
|
setSenderAccountId(value: string): SignOfferRequest;
|
|
|
|
getOfferPayload(): OfferPayload | undefined;
|
|
setOfferPayload(value?: OfferPayload): SignOfferRequest;
|
|
hasOfferPayload(): boolean;
|
|
clearOfferPayload(): SignOfferRequest;
|
|
|
|
getUid(): string;
|
|
setUid(value: string): SignOfferRequest;
|
|
|
|
getCurrentDate(): number;
|
|
setCurrentDate(value: number): SignOfferRequest;
|
|
|
|
getReserveTxHash(): string;
|
|
setReserveTxHash(value: string): SignOfferRequest;
|
|
|
|
getReserveTxHex(): string;
|
|
setReserveTxHex(value: string): SignOfferRequest;
|
|
|
|
getReserveTxKey(): string;
|
|
setReserveTxKey(value: string): SignOfferRequest;
|
|
|
|
getReserveTxKeyImagesList(): Array<string>;
|
|
setReserveTxKeyImagesList(value: Array<string>): SignOfferRequest;
|
|
clearReserveTxKeyImagesList(): SignOfferRequest;
|
|
addReserveTxKeyImages(value: string, index?: number): SignOfferRequest;
|
|
|
|
getPayoutAddress(): string;
|
|
setPayoutAddress(value: string): SignOfferRequest;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): SignOfferRequest.AsObject;
|
|
static toObject(includeInstance: boolean, msg: SignOfferRequest): SignOfferRequest.AsObject;
|
|
static serializeBinaryToWriter(message: SignOfferRequest, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): SignOfferRequest;
|
|
static deserializeBinaryFromReader(message: SignOfferRequest, reader: jspb.BinaryReader): SignOfferRequest;
|
|
}
|
|
|
|
export namespace SignOfferRequest {
|
|
export type AsObject = {
|
|
offerId: string,
|
|
senderNodeAddress?: NodeAddress.AsObject,
|
|
pubKeyRing?: PubKeyRing.AsObject,
|
|
senderAccountId: string,
|
|
offerPayload?: OfferPayload.AsObject,
|
|
uid: string,
|
|
currentDate: number,
|
|
reserveTxHash: string,
|
|
reserveTxHex: string,
|
|
reserveTxKey: string,
|
|
reserveTxKeyImagesList: Array<string>,
|
|
payoutAddress: string,
|
|
}
|
|
}
|
|
|
|
export class SignOfferResponse extends jspb.Message {
|
|
getOfferId(): string;
|
|
setOfferId(value: string): SignOfferResponse;
|
|
|
|
getUid(): string;
|
|
setUid(value: string): SignOfferResponse;
|
|
|
|
getSignedOfferPayload(): OfferPayload | undefined;
|
|
setSignedOfferPayload(value?: OfferPayload): SignOfferResponse;
|
|
hasSignedOfferPayload(): boolean;
|
|
clearSignedOfferPayload(): SignOfferResponse;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): SignOfferResponse.AsObject;
|
|
static toObject(includeInstance: boolean, msg: SignOfferResponse): SignOfferResponse.AsObject;
|
|
static serializeBinaryToWriter(message: SignOfferResponse, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): SignOfferResponse;
|
|
static deserializeBinaryFromReader(message: SignOfferResponse, reader: jspb.BinaryReader): SignOfferResponse;
|
|
}
|
|
|
|
export namespace SignOfferResponse {
|
|
export type AsObject = {
|
|
offerId: string,
|
|
uid: string,
|
|
signedOfferPayload?: OfferPayload.AsObject,
|
|
}
|
|
}
|
|
|
|
export class OfferAvailabilityRequest extends jspb.Message {
|
|
getOfferId(): string;
|
|
setOfferId(value: string): OfferAvailabilityRequest;
|
|
|
|
getPubKeyRing(): PubKeyRing | undefined;
|
|
setPubKeyRing(value?: PubKeyRing): OfferAvailabilityRequest;
|
|
hasPubKeyRing(): boolean;
|
|
clearPubKeyRing(): OfferAvailabilityRequest;
|
|
|
|
getTakersTradePrice(): number;
|
|
setTakersTradePrice(value: number): OfferAvailabilityRequest;
|
|
|
|
getSupportedCapabilitiesList(): Array<number>;
|
|
setSupportedCapabilitiesList(value: Array<number>): OfferAvailabilityRequest;
|
|
clearSupportedCapabilitiesList(): OfferAvailabilityRequest;
|
|
addSupportedCapabilities(value: number, index?: number): OfferAvailabilityRequest;
|
|
|
|
getUid(): string;
|
|
setUid(value: string): OfferAvailabilityRequest;
|
|
|
|
getIsTakerApiUser(): boolean;
|
|
setIsTakerApiUser(value: boolean): OfferAvailabilityRequest;
|
|
|
|
getTradeRequest(): InitTradeRequest | undefined;
|
|
setTradeRequest(value?: InitTradeRequest): OfferAvailabilityRequest;
|
|
hasTradeRequest(): boolean;
|
|
clearTradeRequest(): OfferAvailabilityRequest;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): OfferAvailabilityRequest.AsObject;
|
|
static toObject(includeInstance: boolean, msg: OfferAvailabilityRequest): OfferAvailabilityRequest.AsObject;
|
|
static serializeBinaryToWriter(message: OfferAvailabilityRequest, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): OfferAvailabilityRequest;
|
|
static deserializeBinaryFromReader(message: OfferAvailabilityRequest, reader: jspb.BinaryReader): OfferAvailabilityRequest;
|
|
}
|
|
|
|
export namespace OfferAvailabilityRequest {
|
|
export type AsObject = {
|
|
offerId: string,
|
|
pubKeyRing?: PubKeyRing.AsObject,
|
|
takersTradePrice: number,
|
|
supportedCapabilitiesList: Array<number>,
|
|
uid: string,
|
|
isTakerApiUser: boolean,
|
|
tradeRequest?: InitTradeRequest.AsObject,
|
|
}
|
|
}
|
|
|
|
export class OfferAvailabilityResponse extends jspb.Message {
|
|
getOfferId(): string;
|
|
setOfferId(value: string): OfferAvailabilityResponse;
|
|
|
|
getAvailabilityResult(): AvailabilityResult;
|
|
setAvailabilityResult(value: AvailabilityResult): OfferAvailabilityResponse;
|
|
|
|
getSupportedCapabilitiesList(): Array<number>;
|
|
setSupportedCapabilitiesList(value: Array<number>): OfferAvailabilityResponse;
|
|
clearSupportedCapabilitiesList(): OfferAvailabilityResponse;
|
|
addSupportedCapabilities(value: number, index?: number): OfferAvailabilityResponse;
|
|
|
|
getUid(): string;
|
|
setUid(value: string): OfferAvailabilityResponse;
|
|
|
|
getMakerSignature(): string;
|
|
setMakerSignature(value: string): OfferAvailabilityResponse;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): OfferAvailabilityResponse.AsObject;
|
|
static toObject(includeInstance: boolean, msg: OfferAvailabilityResponse): OfferAvailabilityResponse.AsObject;
|
|
static serializeBinaryToWriter(message: OfferAvailabilityResponse, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): OfferAvailabilityResponse;
|
|
static deserializeBinaryFromReader(message: OfferAvailabilityResponse, reader: jspb.BinaryReader): OfferAvailabilityResponse;
|
|
}
|
|
|
|
export namespace OfferAvailabilityResponse {
|
|
export type AsObject = {
|
|
offerId: string,
|
|
availabilityResult: AvailabilityResult,
|
|
supportedCapabilitiesList: Array<number>,
|
|
uid: string,
|
|
makerSignature: string,
|
|
}
|
|
}
|
|
|
|
export class RefreshOfferMessage extends jspb.Message {
|
|
getHashOfDataAndSeqNr(): Uint8Array | string;
|
|
getHashOfDataAndSeqNr_asU8(): Uint8Array;
|
|
getHashOfDataAndSeqNr_asB64(): string;
|
|
setHashOfDataAndSeqNr(value: Uint8Array | string): RefreshOfferMessage;
|
|
|
|
getSignature(): Uint8Array | string;
|
|
getSignature_asU8(): Uint8Array;
|
|
getSignature_asB64(): string;
|
|
setSignature(value: Uint8Array | string): RefreshOfferMessage;
|
|
|
|
getHashOfPayload(): Uint8Array | string;
|
|
getHashOfPayload_asU8(): Uint8Array;
|
|
getHashOfPayload_asB64(): string;
|
|
setHashOfPayload(value: Uint8Array | string): RefreshOfferMessage;
|
|
|
|
getSequenceNumber(): number;
|
|
setSequenceNumber(value: number): RefreshOfferMessage;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): RefreshOfferMessage.AsObject;
|
|
static toObject(includeInstance: boolean, msg: RefreshOfferMessage): RefreshOfferMessage.AsObject;
|
|
static serializeBinaryToWriter(message: RefreshOfferMessage, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): RefreshOfferMessage;
|
|
static deserializeBinaryFromReader(message: RefreshOfferMessage, reader: jspb.BinaryReader): RefreshOfferMessage;
|
|
}
|
|
|
|
export namespace RefreshOfferMessage {
|
|
export type AsObject = {
|
|
hashOfDataAndSeqNr: Uint8Array | string,
|
|
signature: Uint8Array | string,
|
|
hashOfPayload: Uint8Array | string,
|
|
sequenceNumber: number,
|
|
}
|
|
}
|
|
|
|
export class AddDataMessage extends jspb.Message {
|
|
getEntry(): StorageEntryWrapper | undefined;
|
|
setEntry(value?: StorageEntryWrapper): AddDataMessage;
|
|
hasEntry(): boolean;
|
|
clearEntry(): AddDataMessage;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): AddDataMessage.AsObject;
|
|
static toObject(includeInstance: boolean, msg: AddDataMessage): AddDataMessage.AsObject;
|
|
static serializeBinaryToWriter(message: AddDataMessage, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): AddDataMessage;
|
|
static deserializeBinaryFromReader(message: AddDataMessage, reader: jspb.BinaryReader): AddDataMessage;
|
|
}
|
|
|
|
export namespace AddDataMessage {
|
|
export type AsObject = {
|
|
entry?: StorageEntryWrapper.AsObject,
|
|
}
|
|
}
|
|
|
|
export class RemoveDataMessage extends jspb.Message {
|
|
getProtectedStorageEntry(): ProtectedStorageEntry | undefined;
|
|
setProtectedStorageEntry(value?: ProtectedStorageEntry): RemoveDataMessage;
|
|
hasProtectedStorageEntry(): boolean;
|
|
clearProtectedStorageEntry(): RemoveDataMessage;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): RemoveDataMessage.AsObject;
|
|
static toObject(includeInstance: boolean, msg: RemoveDataMessage): RemoveDataMessage.AsObject;
|
|
static serializeBinaryToWriter(message: RemoveDataMessage, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): RemoveDataMessage;
|
|
static deserializeBinaryFromReader(message: RemoveDataMessage, reader: jspb.BinaryReader): RemoveDataMessage;
|
|
}
|
|
|
|
export namespace RemoveDataMessage {
|
|
export type AsObject = {
|
|
protectedStorageEntry?: ProtectedStorageEntry.AsObject,
|
|
}
|
|
}
|
|
|
|
export class RemoveMailboxDataMessage extends jspb.Message {
|
|
getProtectedStorageEntry(): ProtectedMailboxStorageEntry | undefined;
|
|
setProtectedStorageEntry(value?: ProtectedMailboxStorageEntry): RemoveMailboxDataMessage;
|
|
hasProtectedStorageEntry(): boolean;
|
|
clearProtectedStorageEntry(): RemoveMailboxDataMessage;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): RemoveMailboxDataMessage.AsObject;
|
|
static toObject(includeInstance: boolean, msg: RemoveMailboxDataMessage): RemoveMailboxDataMessage.AsObject;
|
|
static serializeBinaryToWriter(message: RemoveMailboxDataMessage, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): RemoveMailboxDataMessage;
|
|
static deserializeBinaryFromReader(message: RemoveMailboxDataMessage, reader: jspb.BinaryReader): RemoveMailboxDataMessage;
|
|
}
|
|
|
|
export namespace RemoveMailboxDataMessage {
|
|
export type AsObject = {
|
|
protectedStorageEntry?: ProtectedMailboxStorageEntry.AsObject,
|
|
}
|
|
}
|
|
|
|
export class AddPersistableNetworkPayloadMessage extends jspb.Message {
|
|
getPayload(): PersistableNetworkPayload | undefined;
|
|
setPayload(value?: PersistableNetworkPayload): AddPersistableNetworkPayloadMessage;
|
|
hasPayload(): boolean;
|
|
clearPayload(): AddPersistableNetworkPayloadMessage;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): AddPersistableNetworkPayloadMessage.AsObject;
|
|
static toObject(includeInstance: boolean, msg: AddPersistableNetworkPayloadMessage): AddPersistableNetworkPayloadMessage.AsObject;
|
|
static serializeBinaryToWriter(message: AddPersistableNetworkPayloadMessage, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): AddPersistableNetworkPayloadMessage;
|
|
static deserializeBinaryFromReader(message: AddPersistableNetworkPayloadMessage, reader: jspb.BinaryReader): AddPersistableNetworkPayloadMessage;
|
|
}
|
|
|
|
export namespace AddPersistableNetworkPayloadMessage {
|
|
export type AsObject = {
|
|
payload?: PersistableNetworkPayload.AsObject,
|
|
}
|
|
}
|
|
|
|
export class CloseConnectionMessage extends jspb.Message {
|
|
getReason(): string;
|
|
setReason(value: string): CloseConnectionMessage;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): CloseConnectionMessage.AsObject;
|
|
static toObject(includeInstance: boolean, msg: CloseConnectionMessage): CloseConnectionMessage.AsObject;
|
|
static serializeBinaryToWriter(message: CloseConnectionMessage, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): CloseConnectionMessage;
|
|
static deserializeBinaryFromReader(message: CloseConnectionMessage, reader: jspb.BinaryReader): CloseConnectionMessage;
|
|
}
|
|
|
|
export namespace CloseConnectionMessage {
|
|
export type AsObject = {
|
|
reason: string,
|
|
}
|
|
}
|
|
|
|
export class AckMessage extends jspb.Message {
|
|
getUid(): string;
|
|
setUid(value: string): AckMessage;
|
|
|
|
getSenderNodeAddress(): NodeAddress | undefined;
|
|
setSenderNodeAddress(value?: NodeAddress): AckMessage;
|
|
hasSenderNodeAddress(): boolean;
|
|
clearSenderNodeAddress(): AckMessage;
|
|
|
|
getSourceType(): string;
|
|
setSourceType(value: string): AckMessage;
|
|
|
|
getSourceMsgClassName(): string;
|
|
setSourceMsgClassName(value: string): AckMessage;
|
|
|
|
getSourceUid(): string;
|
|
setSourceUid(value: string): AckMessage;
|
|
|
|
getSourceId(): string;
|
|
setSourceId(value: string): AckMessage;
|
|
|
|
getSuccess(): boolean;
|
|
setSuccess(value: boolean): AckMessage;
|
|
|
|
getErrorMessage(): string;
|
|
setErrorMessage(value: string): AckMessage;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): AckMessage.AsObject;
|
|
static toObject(includeInstance: boolean, msg: AckMessage): AckMessage.AsObject;
|
|
static serializeBinaryToWriter(message: AckMessage, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): AckMessage;
|
|
static deserializeBinaryFromReader(message: AckMessage, reader: jspb.BinaryReader): AckMessage;
|
|
}
|
|
|
|
export namespace AckMessage {
|
|
export type AsObject = {
|
|
uid: string,
|
|
senderNodeAddress?: NodeAddress.AsObject,
|
|
sourceType: string,
|
|
sourceMsgClassName: string,
|
|
sourceUid: string,
|
|
sourceId: string,
|
|
success: boolean,
|
|
errorMessage: string,
|
|
}
|
|
}
|
|
|
|
export class PrefixedSealedAndSignedMessage extends jspb.Message {
|
|
getNodeAddress(): NodeAddress | undefined;
|
|
setNodeAddress(value?: NodeAddress): PrefixedSealedAndSignedMessage;
|
|
hasNodeAddress(): boolean;
|
|
clearNodeAddress(): PrefixedSealedAndSignedMessage;
|
|
|
|
getSealedAndSigned(): SealedAndSigned | undefined;
|
|
setSealedAndSigned(value?: SealedAndSigned): PrefixedSealedAndSignedMessage;
|
|
hasSealedAndSigned(): boolean;
|
|
clearSealedAndSigned(): PrefixedSealedAndSignedMessage;
|
|
|
|
getAddressPrefixHash(): Uint8Array | string;
|
|
getAddressPrefixHash_asU8(): Uint8Array;
|
|
getAddressPrefixHash_asB64(): string;
|
|
setAddressPrefixHash(value: Uint8Array | string): PrefixedSealedAndSignedMessage;
|
|
|
|
getUid(): string;
|
|
setUid(value: string): PrefixedSealedAndSignedMessage;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PrefixedSealedAndSignedMessage.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PrefixedSealedAndSignedMessage): PrefixedSealedAndSignedMessage.AsObject;
|
|
static serializeBinaryToWriter(message: PrefixedSealedAndSignedMessage, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PrefixedSealedAndSignedMessage;
|
|
static deserializeBinaryFromReader(message: PrefixedSealedAndSignedMessage, reader: jspb.BinaryReader): PrefixedSealedAndSignedMessage;
|
|
}
|
|
|
|
export namespace PrefixedSealedAndSignedMessage {
|
|
export type AsObject = {
|
|
nodeAddress?: NodeAddress.AsObject,
|
|
sealedAndSigned?: SealedAndSigned.AsObject,
|
|
addressPrefixHash: Uint8Array | string,
|
|
uid: string,
|
|
}
|
|
}
|
|
|
|
export class InputsForDepositTxRequest extends jspb.Message {
|
|
getTradeId(): string;
|
|
setTradeId(value: string): InputsForDepositTxRequest;
|
|
|
|
getSenderNodeAddress(): NodeAddress | undefined;
|
|
setSenderNodeAddress(value?: NodeAddress): InputsForDepositTxRequest;
|
|
hasSenderNodeAddress(): boolean;
|
|
clearSenderNodeAddress(): InputsForDepositTxRequest;
|
|
|
|
getTradeAmount(): number;
|
|
setTradeAmount(value: number): InputsForDepositTxRequest;
|
|
|
|
getTradePrice(): number;
|
|
setTradePrice(value: number): InputsForDepositTxRequest;
|
|
|
|
getTxFee(): number;
|
|
setTxFee(value: number): InputsForDepositTxRequest;
|
|
|
|
getTakerFee(): number;
|
|
setTakerFee(value: number): InputsForDepositTxRequest;
|
|
|
|
getRawTransactionInputsList(): Array<RawTransactionInput>;
|
|
setRawTransactionInputsList(value: Array<RawTransactionInput>): InputsForDepositTxRequest;
|
|
clearRawTransactionInputsList(): InputsForDepositTxRequest;
|
|
addRawTransactionInputs(value?: RawTransactionInput, index?: number): RawTransactionInput;
|
|
|
|
getChangeOutputValue(): number;
|
|
setChangeOutputValue(value: number): InputsForDepositTxRequest;
|
|
|
|
getChangeOutputAddress(): string;
|
|
setChangeOutputAddress(value: string): InputsForDepositTxRequest;
|
|
|
|
getTakerMultiSigPubKey(): Uint8Array | string;
|
|
getTakerMultiSigPubKey_asU8(): Uint8Array;
|
|
getTakerMultiSigPubKey_asB64(): string;
|
|
setTakerMultiSigPubKey(value: Uint8Array | string): InputsForDepositTxRequest;
|
|
|
|
getTakerPayoutAddressString(): string;
|
|
setTakerPayoutAddressString(value: string): InputsForDepositTxRequest;
|
|
|
|
getTakerPubKeyRing(): PubKeyRing | undefined;
|
|
setTakerPubKeyRing(value?: PubKeyRing): InputsForDepositTxRequest;
|
|
hasTakerPubKeyRing(): boolean;
|
|
clearTakerPubKeyRing(): InputsForDepositTxRequest;
|
|
|
|
getTakerPaymentAccountPayload(): PaymentAccountPayload | undefined;
|
|
setTakerPaymentAccountPayload(value?: PaymentAccountPayload): InputsForDepositTxRequest;
|
|
hasTakerPaymentAccountPayload(): boolean;
|
|
clearTakerPaymentAccountPayload(): InputsForDepositTxRequest;
|
|
|
|
getTakerAccountId(): string;
|
|
setTakerAccountId(value: string): InputsForDepositTxRequest;
|
|
|
|
getTakerFeeTxId(): string;
|
|
setTakerFeeTxId(value: string): InputsForDepositTxRequest;
|
|
|
|
getAcceptedArbitratorNodeAddressesList(): Array<NodeAddress>;
|
|
setAcceptedArbitratorNodeAddressesList(value: Array<NodeAddress>): InputsForDepositTxRequest;
|
|
clearAcceptedArbitratorNodeAddressesList(): InputsForDepositTxRequest;
|
|
addAcceptedArbitratorNodeAddresses(value?: NodeAddress, index?: number): NodeAddress;
|
|
|
|
getAcceptedMediatorNodeAddressesList(): Array<NodeAddress>;
|
|
setAcceptedMediatorNodeAddressesList(value: Array<NodeAddress>): InputsForDepositTxRequest;
|
|
clearAcceptedMediatorNodeAddressesList(): InputsForDepositTxRequest;
|
|
addAcceptedMediatorNodeAddresses(value?: NodeAddress, index?: number): NodeAddress;
|
|
|
|
getArbitratorNodeAddress(): NodeAddress | undefined;
|
|
setArbitratorNodeAddress(value?: NodeAddress): InputsForDepositTxRequest;
|
|
hasArbitratorNodeAddress(): boolean;
|
|
clearArbitratorNodeAddress(): InputsForDepositTxRequest;
|
|
|
|
getMediatorNodeAddress(): NodeAddress | undefined;
|
|
setMediatorNodeAddress(value?: NodeAddress): InputsForDepositTxRequest;
|
|
hasMediatorNodeAddress(): boolean;
|
|
clearMediatorNodeAddress(): InputsForDepositTxRequest;
|
|
|
|
getUid(): string;
|
|
setUid(value: string): InputsForDepositTxRequest;
|
|
|
|
getAccountAgeWitnessSignatureOfOfferId(): Uint8Array | string;
|
|
getAccountAgeWitnessSignatureOfOfferId_asU8(): Uint8Array;
|
|
getAccountAgeWitnessSignatureOfOfferId_asB64(): string;
|
|
setAccountAgeWitnessSignatureOfOfferId(value: Uint8Array | string): InputsForDepositTxRequest;
|
|
|
|
getCurrentDate(): number;
|
|
setCurrentDate(value: number): InputsForDepositTxRequest;
|
|
|
|
getAcceptedRefundAgentNodeAddressesList(): Array<NodeAddress>;
|
|
setAcceptedRefundAgentNodeAddressesList(value: Array<NodeAddress>): InputsForDepositTxRequest;
|
|
clearAcceptedRefundAgentNodeAddressesList(): InputsForDepositTxRequest;
|
|
addAcceptedRefundAgentNodeAddresses(value?: NodeAddress, index?: number): NodeAddress;
|
|
|
|
getRefundAgentNodeAddress(): NodeAddress | undefined;
|
|
setRefundAgentNodeAddress(value?: NodeAddress): InputsForDepositTxRequest;
|
|
hasRefundAgentNodeAddress(): boolean;
|
|
clearRefundAgentNodeAddress(): InputsForDepositTxRequest;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): InputsForDepositTxRequest.AsObject;
|
|
static toObject(includeInstance: boolean, msg: InputsForDepositTxRequest): InputsForDepositTxRequest.AsObject;
|
|
static serializeBinaryToWriter(message: InputsForDepositTxRequest, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): InputsForDepositTxRequest;
|
|
static deserializeBinaryFromReader(message: InputsForDepositTxRequest, reader: jspb.BinaryReader): InputsForDepositTxRequest;
|
|
}
|
|
|
|
export namespace InputsForDepositTxRequest {
|
|
export type AsObject = {
|
|
tradeId: string,
|
|
senderNodeAddress?: NodeAddress.AsObject,
|
|
tradeAmount: number,
|
|
tradePrice: number,
|
|
txFee: number,
|
|
takerFee: number,
|
|
rawTransactionInputsList: Array<RawTransactionInput.AsObject>,
|
|
changeOutputValue: number,
|
|
changeOutputAddress: string,
|
|
takerMultiSigPubKey: Uint8Array | string,
|
|
takerPayoutAddressString: string,
|
|
takerPubKeyRing?: PubKeyRing.AsObject,
|
|
takerPaymentAccountPayload?: PaymentAccountPayload.AsObject,
|
|
takerAccountId: string,
|
|
takerFeeTxId: string,
|
|
acceptedArbitratorNodeAddressesList: Array<NodeAddress.AsObject>,
|
|
acceptedMediatorNodeAddressesList: Array<NodeAddress.AsObject>,
|
|
arbitratorNodeAddress?: NodeAddress.AsObject,
|
|
mediatorNodeAddress?: NodeAddress.AsObject,
|
|
uid: string,
|
|
accountAgeWitnessSignatureOfOfferId: Uint8Array | string,
|
|
currentDate: number,
|
|
acceptedRefundAgentNodeAddressesList: Array<NodeAddress.AsObject>,
|
|
refundAgentNodeAddress?: NodeAddress.AsObject,
|
|
}
|
|
}
|
|
|
|
export class InputsForDepositTxResponse extends jspb.Message {
|
|
getTradeId(): string;
|
|
setTradeId(value: string): InputsForDepositTxResponse;
|
|
|
|
getMakerPaymentAccountPayload(): PaymentAccountPayload | undefined;
|
|
setMakerPaymentAccountPayload(value?: PaymentAccountPayload): InputsForDepositTxResponse;
|
|
hasMakerPaymentAccountPayload(): boolean;
|
|
clearMakerPaymentAccountPayload(): InputsForDepositTxResponse;
|
|
|
|
getMakerAccountId(): string;
|
|
setMakerAccountId(value: string): InputsForDepositTxResponse;
|
|
|
|
getMakerContractAsJson(): string;
|
|
setMakerContractAsJson(value: string): InputsForDepositTxResponse;
|
|
|
|
getMakerContractSignature(): string;
|
|
setMakerContractSignature(value: string): InputsForDepositTxResponse;
|
|
|
|
getMakerPayoutAddressString(): string;
|
|
setMakerPayoutAddressString(value: string): InputsForDepositTxResponse;
|
|
|
|
getPreparedDepositTx(): Uint8Array | string;
|
|
getPreparedDepositTx_asU8(): Uint8Array;
|
|
getPreparedDepositTx_asB64(): string;
|
|
setPreparedDepositTx(value: Uint8Array | string): InputsForDepositTxResponse;
|
|
|
|
getMakerInputsList(): Array<RawTransactionInput>;
|
|
setMakerInputsList(value: Array<RawTransactionInput>): InputsForDepositTxResponse;
|
|
clearMakerInputsList(): InputsForDepositTxResponse;
|
|
addMakerInputs(value?: RawTransactionInput, index?: number): RawTransactionInput;
|
|
|
|
getMakerMultiSigPubKey(): Uint8Array | string;
|
|
getMakerMultiSigPubKey_asU8(): Uint8Array;
|
|
getMakerMultiSigPubKey_asB64(): string;
|
|
setMakerMultiSigPubKey(value: Uint8Array | string): InputsForDepositTxResponse;
|
|
|
|
getSenderNodeAddress(): NodeAddress | undefined;
|
|
setSenderNodeAddress(value?: NodeAddress): InputsForDepositTxResponse;
|
|
hasSenderNodeAddress(): boolean;
|
|
clearSenderNodeAddress(): InputsForDepositTxResponse;
|
|
|
|
getUid(): string;
|
|
setUid(value: string): InputsForDepositTxResponse;
|
|
|
|
getAccountAgeWitnessSignatureOfPreparedDepositTx(): Uint8Array | string;
|
|
getAccountAgeWitnessSignatureOfPreparedDepositTx_asU8(): Uint8Array;
|
|
getAccountAgeWitnessSignatureOfPreparedDepositTx_asB64(): string;
|
|
setAccountAgeWitnessSignatureOfPreparedDepositTx(value: Uint8Array | string): InputsForDepositTxResponse;
|
|
|
|
getCurrentDate(): number;
|
|
setCurrentDate(value: number): InputsForDepositTxResponse;
|
|
|
|
getLockTime(): number;
|
|
setLockTime(value: number): InputsForDepositTxResponse;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): InputsForDepositTxResponse.AsObject;
|
|
static toObject(includeInstance: boolean, msg: InputsForDepositTxResponse): InputsForDepositTxResponse.AsObject;
|
|
static serializeBinaryToWriter(message: InputsForDepositTxResponse, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): InputsForDepositTxResponse;
|
|
static deserializeBinaryFromReader(message: InputsForDepositTxResponse, reader: jspb.BinaryReader): InputsForDepositTxResponse;
|
|
}
|
|
|
|
export namespace InputsForDepositTxResponse {
|
|
export type AsObject = {
|
|
tradeId: string,
|
|
makerPaymentAccountPayload?: PaymentAccountPayload.AsObject,
|
|
makerAccountId: string,
|
|
makerContractAsJson: string,
|
|
makerContractSignature: string,
|
|
makerPayoutAddressString: string,
|
|
preparedDepositTx: Uint8Array | string,
|
|
makerInputsList: Array<RawTransactionInput.AsObject>,
|
|
makerMultiSigPubKey: Uint8Array | string,
|
|
senderNodeAddress?: NodeAddress.AsObject,
|
|
uid: string,
|
|
accountAgeWitnessSignatureOfPreparedDepositTx: Uint8Array | string,
|
|
currentDate: number,
|
|
lockTime: number,
|
|
}
|
|
}
|
|
|
|
export class InitTradeRequest extends jspb.Message {
|
|
getTradeId(): string;
|
|
setTradeId(value: string): InitTradeRequest;
|
|
|
|
getSenderNodeAddress(): NodeAddress | undefined;
|
|
setSenderNodeAddress(value?: NodeAddress): InitTradeRequest;
|
|
hasSenderNodeAddress(): boolean;
|
|
clearSenderNodeAddress(): InitTradeRequest;
|
|
|
|
getPubKeyRing(): PubKeyRing | undefined;
|
|
setPubKeyRing(value?: PubKeyRing): InitTradeRequest;
|
|
hasPubKeyRing(): boolean;
|
|
clearPubKeyRing(): InitTradeRequest;
|
|
|
|
getTradeAmount(): number;
|
|
setTradeAmount(value: number): InitTradeRequest;
|
|
|
|
getTradePrice(): number;
|
|
setTradePrice(value: number): InitTradeRequest;
|
|
|
|
getTradeFee(): number;
|
|
setTradeFee(value: number): InitTradeRequest;
|
|
|
|
getAccountId(): string;
|
|
setAccountId(value: string): InitTradeRequest;
|
|
|
|
getPaymentAccountId(): string;
|
|
setPaymentAccountId(value: string): InitTradeRequest;
|
|
|
|
getPaymentMethodId(): string;
|
|
setPaymentMethodId(value: string): InitTradeRequest;
|
|
|
|
getUid(): string;
|
|
setUid(value: string): InitTradeRequest;
|
|
|
|
getAccountAgeWitnessSignatureOfOfferId(): Uint8Array | string;
|
|
getAccountAgeWitnessSignatureOfOfferId_asU8(): Uint8Array;
|
|
getAccountAgeWitnessSignatureOfOfferId_asB64(): string;
|
|
setAccountAgeWitnessSignatureOfOfferId(value: Uint8Array | string): InitTradeRequest;
|
|
|
|
getCurrentDate(): number;
|
|
setCurrentDate(value: number): InitTradeRequest;
|
|
|
|
getMakerNodeAddress(): NodeAddress | undefined;
|
|
setMakerNodeAddress(value?: NodeAddress): InitTradeRequest;
|
|
hasMakerNodeAddress(): boolean;
|
|
clearMakerNodeAddress(): InitTradeRequest;
|
|
|
|
getTakerNodeAddress(): NodeAddress | undefined;
|
|
setTakerNodeAddress(value?: NodeAddress): InitTradeRequest;
|
|
hasTakerNodeAddress(): boolean;
|
|
clearTakerNodeAddress(): InitTradeRequest;
|
|
|
|
getArbitratorNodeAddress(): NodeAddress | undefined;
|
|
setArbitratorNodeAddress(value?: NodeAddress): InitTradeRequest;
|
|
hasArbitratorNodeAddress(): boolean;
|
|
clearArbitratorNodeAddress(): InitTradeRequest;
|
|
|
|
getReserveTxHash(): string;
|
|
setReserveTxHash(value: string): InitTradeRequest;
|
|
|
|
getReserveTxHex(): string;
|
|
setReserveTxHex(value: string): InitTradeRequest;
|
|
|
|
getReserveTxKey(): string;
|
|
setReserveTxKey(value: string): InitTradeRequest;
|
|
|
|
getPayoutAddress(): string;
|
|
setPayoutAddress(value: string): InitTradeRequest;
|
|
|
|
getMakerSignature(): string;
|
|
setMakerSignature(value: string): InitTradeRequest;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): InitTradeRequest.AsObject;
|
|
static toObject(includeInstance: boolean, msg: InitTradeRequest): InitTradeRequest.AsObject;
|
|
static serializeBinaryToWriter(message: InitTradeRequest, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): InitTradeRequest;
|
|
static deserializeBinaryFromReader(message: InitTradeRequest, reader: jspb.BinaryReader): InitTradeRequest;
|
|
}
|
|
|
|
export namespace InitTradeRequest {
|
|
export type AsObject = {
|
|
tradeId: string,
|
|
senderNodeAddress?: NodeAddress.AsObject,
|
|
pubKeyRing?: PubKeyRing.AsObject,
|
|
tradeAmount: number,
|
|
tradePrice: number,
|
|
tradeFee: number,
|
|
accountId: string,
|
|
paymentAccountId: string,
|
|
paymentMethodId: string,
|
|
uid: string,
|
|
accountAgeWitnessSignatureOfOfferId: Uint8Array | string,
|
|
currentDate: number,
|
|
makerNodeAddress?: NodeAddress.AsObject,
|
|
takerNodeAddress?: NodeAddress.AsObject,
|
|
arbitratorNodeAddress?: NodeAddress.AsObject,
|
|
reserveTxHash: string,
|
|
reserveTxHex: string,
|
|
reserveTxKey: string,
|
|
payoutAddress: string,
|
|
makerSignature: string,
|
|
}
|
|
}
|
|
|
|
export class InitMultisigRequest extends jspb.Message {
|
|
getTradeId(): string;
|
|
setTradeId(value: string): InitMultisigRequest;
|
|
|
|
getUid(): string;
|
|
setUid(value: string): InitMultisigRequest;
|
|
|
|
getCurrentDate(): number;
|
|
setCurrentDate(value: number): InitMultisigRequest;
|
|
|
|
getPreparedMultisigHex(): string;
|
|
setPreparedMultisigHex(value: string): InitMultisigRequest;
|
|
|
|
getMadeMultisigHex(): string;
|
|
setMadeMultisigHex(value: string): InitMultisigRequest;
|
|
|
|
getExchangedMultisigHex(): string;
|
|
setExchangedMultisigHex(value: string): InitMultisigRequest;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): InitMultisigRequest.AsObject;
|
|
static toObject(includeInstance: boolean, msg: InitMultisigRequest): InitMultisigRequest.AsObject;
|
|
static serializeBinaryToWriter(message: InitMultisigRequest, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): InitMultisigRequest;
|
|
static deserializeBinaryFromReader(message: InitMultisigRequest, reader: jspb.BinaryReader): InitMultisigRequest;
|
|
}
|
|
|
|
export namespace InitMultisigRequest {
|
|
export type AsObject = {
|
|
tradeId: string,
|
|
uid: string,
|
|
currentDate: number,
|
|
preparedMultisigHex: string,
|
|
madeMultisigHex: string,
|
|
exchangedMultisigHex: string,
|
|
}
|
|
}
|
|
|
|
export class SignContractRequest extends jspb.Message {
|
|
getTradeId(): string;
|
|
setTradeId(value: string): SignContractRequest;
|
|
|
|
getUid(): string;
|
|
setUid(value: string): SignContractRequest;
|
|
|
|
getCurrentDate(): number;
|
|
setCurrentDate(value: number): SignContractRequest;
|
|
|
|
getAccountId(): string;
|
|
setAccountId(value: string): SignContractRequest;
|
|
|
|
getPaymentAccountPayloadHash(): Uint8Array | string;
|
|
getPaymentAccountPayloadHash_asU8(): Uint8Array;
|
|
getPaymentAccountPayloadHash_asB64(): string;
|
|
setPaymentAccountPayloadHash(value: Uint8Array | string): SignContractRequest;
|
|
|
|
getPayoutAddress(): string;
|
|
setPayoutAddress(value: string): SignContractRequest;
|
|
|
|
getDepositTxHash(): string;
|
|
setDepositTxHash(value: string): SignContractRequest;
|
|
|
|
getAccountAgeWitnessSignatureOfDepositHash(): Uint8Array | string;
|
|
getAccountAgeWitnessSignatureOfDepositHash_asU8(): Uint8Array;
|
|
getAccountAgeWitnessSignatureOfDepositHash_asB64(): string;
|
|
setAccountAgeWitnessSignatureOfDepositHash(value: Uint8Array | string): SignContractRequest;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): SignContractRequest.AsObject;
|
|
static toObject(includeInstance: boolean, msg: SignContractRequest): SignContractRequest.AsObject;
|
|
static serializeBinaryToWriter(message: SignContractRequest, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): SignContractRequest;
|
|
static deserializeBinaryFromReader(message: SignContractRequest, reader: jspb.BinaryReader): SignContractRequest;
|
|
}
|
|
|
|
export namespace SignContractRequest {
|
|
export type AsObject = {
|
|
tradeId: string,
|
|
uid: string,
|
|
currentDate: number,
|
|
accountId: string,
|
|
paymentAccountPayloadHash: Uint8Array | string,
|
|
payoutAddress: string,
|
|
depositTxHash: string,
|
|
accountAgeWitnessSignatureOfDepositHash: Uint8Array | string,
|
|
}
|
|
}
|
|
|
|
export class SignContractResponse extends jspb.Message {
|
|
getTradeId(): string;
|
|
setTradeId(value: string): SignContractResponse;
|
|
|
|
getUid(): string;
|
|
setUid(value: string): SignContractResponse;
|
|
|
|
getCurrentDate(): number;
|
|
setCurrentDate(value: number): SignContractResponse;
|
|
|
|
getContractAsJson(): string;
|
|
setContractAsJson(value: string): SignContractResponse;
|
|
|
|
getContractSignature(): string;
|
|
setContractSignature(value: string): SignContractResponse;
|
|
|
|
getEncryptedPaymentAccountPayload(): Uint8Array | string;
|
|
getEncryptedPaymentAccountPayload_asU8(): Uint8Array;
|
|
getEncryptedPaymentAccountPayload_asB64(): string;
|
|
setEncryptedPaymentAccountPayload(value: Uint8Array | string): SignContractResponse;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): SignContractResponse.AsObject;
|
|
static toObject(includeInstance: boolean, msg: SignContractResponse): SignContractResponse.AsObject;
|
|
static serializeBinaryToWriter(message: SignContractResponse, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): SignContractResponse;
|
|
static deserializeBinaryFromReader(message: SignContractResponse, reader: jspb.BinaryReader): SignContractResponse;
|
|
}
|
|
|
|
export namespace SignContractResponse {
|
|
export type AsObject = {
|
|
tradeId: string,
|
|
uid: string,
|
|
currentDate: number,
|
|
contractAsJson: string,
|
|
contractSignature: string,
|
|
encryptedPaymentAccountPayload: Uint8Array | string,
|
|
}
|
|
}
|
|
|
|
export class DepositRequest extends jspb.Message {
|
|
getTradeId(): string;
|
|
setTradeId(value: string): DepositRequest;
|
|
|
|
getUid(): string;
|
|
setUid(value: string): DepositRequest;
|
|
|
|
getCurrentDate(): number;
|
|
setCurrentDate(value: number): DepositRequest;
|
|
|
|
getContractSignature(): string;
|
|
setContractSignature(value: string): DepositRequest;
|
|
|
|
getDepositTxHex(): string;
|
|
setDepositTxHex(value: string): DepositRequest;
|
|
|
|
getDepositTxKey(): string;
|
|
setDepositTxKey(value: string): DepositRequest;
|
|
|
|
getPaymentAccountKey(): Uint8Array | string;
|
|
getPaymentAccountKey_asU8(): Uint8Array;
|
|
getPaymentAccountKey_asB64(): string;
|
|
setPaymentAccountKey(value: Uint8Array | string): DepositRequest;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): DepositRequest.AsObject;
|
|
static toObject(includeInstance: boolean, msg: DepositRequest): DepositRequest.AsObject;
|
|
static serializeBinaryToWriter(message: DepositRequest, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): DepositRequest;
|
|
static deserializeBinaryFromReader(message: DepositRequest, reader: jspb.BinaryReader): DepositRequest;
|
|
}
|
|
|
|
export namespace DepositRequest {
|
|
export type AsObject = {
|
|
tradeId: string,
|
|
uid: string,
|
|
currentDate: number,
|
|
contractSignature: string,
|
|
depositTxHex: string,
|
|
depositTxKey: string,
|
|
paymentAccountKey: Uint8Array | string,
|
|
}
|
|
}
|
|
|
|
export class DepositResponse extends jspb.Message {
|
|
getTradeId(): string;
|
|
setTradeId(value: string): DepositResponse;
|
|
|
|
getUid(): string;
|
|
setUid(value: string): DepositResponse;
|
|
|
|
getCurrentDate(): number;
|
|
setCurrentDate(value: number): DepositResponse;
|
|
|
|
getErrorMessage(): string;
|
|
setErrorMessage(value: string): DepositResponse;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): DepositResponse.AsObject;
|
|
static toObject(includeInstance: boolean, msg: DepositResponse): DepositResponse.AsObject;
|
|
static serializeBinaryToWriter(message: DepositResponse, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): DepositResponse;
|
|
static deserializeBinaryFromReader(message: DepositResponse, reader: jspb.BinaryReader): DepositResponse;
|
|
}
|
|
|
|
export namespace DepositResponse {
|
|
export type AsObject = {
|
|
tradeId: string,
|
|
uid: string,
|
|
currentDate: number,
|
|
errorMessage: string,
|
|
}
|
|
}
|
|
|
|
export class DepositsConfirmedMessage extends jspb.Message {
|
|
getTradeId(): string;
|
|
setTradeId(value: string): DepositsConfirmedMessage;
|
|
|
|
getSenderNodeAddress(): NodeAddress | undefined;
|
|
setSenderNodeAddress(value?: NodeAddress): DepositsConfirmedMessage;
|
|
hasSenderNodeAddress(): boolean;
|
|
clearSenderNodeAddress(): DepositsConfirmedMessage;
|
|
|
|
getPubKeyRing(): PubKeyRing | undefined;
|
|
setPubKeyRing(value?: PubKeyRing): DepositsConfirmedMessage;
|
|
hasPubKeyRing(): boolean;
|
|
clearPubKeyRing(): DepositsConfirmedMessage;
|
|
|
|
getUid(): string;
|
|
setUid(value: string): DepositsConfirmedMessage;
|
|
|
|
getSellerPaymentAccountKey(): Uint8Array | string;
|
|
getSellerPaymentAccountKey_asU8(): Uint8Array;
|
|
getSellerPaymentAccountKey_asB64(): string;
|
|
setSellerPaymentAccountKey(value: Uint8Array | string): DepositsConfirmedMessage;
|
|
|
|
getUpdatedMultisigHex(): string;
|
|
setUpdatedMultisigHex(value: string): DepositsConfirmedMessage;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): DepositsConfirmedMessage.AsObject;
|
|
static toObject(includeInstance: boolean, msg: DepositsConfirmedMessage): DepositsConfirmedMessage.AsObject;
|
|
static serializeBinaryToWriter(message: DepositsConfirmedMessage, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): DepositsConfirmedMessage;
|
|
static deserializeBinaryFromReader(message: DepositsConfirmedMessage, reader: jspb.BinaryReader): DepositsConfirmedMessage;
|
|
}
|
|
|
|
export namespace DepositsConfirmedMessage {
|
|
export type AsObject = {
|
|
tradeId: string,
|
|
senderNodeAddress?: NodeAddress.AsObject,
|
|
pubKeyRing?: PubKeyRing.AsObject,
|
|
uid: string,
|
|
sellerPaymentAccountKey: Uint8Array | string,
|
|
updatedMultisigHex: string,
|
|
}
|
|
}
|
|
|
|
export class DelayedPayoutTxSignatureRequest extends jspb.Message {
|
|
getUid(): string;
|
|
setUid(value: string): DelayedPayoutTxSignatureRequest;
|
|
|
|
getTradeId(): string;
|
|
setTradeId(value: string): DelayedPayoutTxSignatureRequest;
|
|
|
|
getSenderNodeAddress(): NodeAddress | undefined;
|
|
setSenderNodeAddress(value?: NodeAddress): DelayedPayoutTxSignatureRequest;
|
|
hasSenderNodeAddress(): boolean;
|
|
clearSenderNodeAddress(): DelayedPayoutTxSignatureRequest;
|
|
|
|
getDelayedPayoutTx(): Uint8Array | string;
|
|
getDelayedPayoutTx_asU8(): Uint8Array;
|
|
getDelayedPayoutTx_asB64(): string;
|
|
setDelayedPayoutTx(value: Uint8Array | string): DelayedPayoutTxSignatureRequest;
|
|
|
|
getDelayedPayoutTxSellerSignature(): Uint8Array | string;
|
|
getDelayedPayoutTxSellerSignature_asU8(): Uint8Array;
|
|
getDelayedPayoutTxSellerSignature_asB64(): string;
|
|
setDelayedPayoutTxSellerSignature(value: Uint8Array | string): DelayedPayoutTxSignatureRequest;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): DelayedPayoutTxSignatureRequest.AsObject;
|
|
static toObject(includeInstance: boolean, msg: DelayedPayoutTxSignatureRequest): DelayedPayoutTxSignatureRequest.AsObject;
|
|
static serializeBinaryToWriter(message: DelayedPayoutTxSignatureRequest, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): DelayedPayoutTxSignatureRequest;
|
|
static deserializeBinaryFromReader(message: DelayedPayoutTxSignatureRequest, reader: jspb.BinaryReader): DelayedPayoutTxSignatureRequest;
|
|
}
|
|
|
|
export namespace DelayedPayoutTxSignatureRequest {
|
|
export type AsObject = {
|
|
uid: string,
|
|
tradeId: string,
|
|
senderNodeAddress?: NodeAddress.AsObject,
|
|
delayedPayoutTx: Uint8Array | string,
|
|
delayedPayoutTxSellerSignature: Uint8Array | string,
|
|
}
|
|
}
|
|
|
|
export class DelayedPayoutTxSignatureResponse extends jspb.Message {
|
|
getUid(): string;
|
|
setUid(value: string): DelayedPayoutTxSignatureResponse;
|
|
|
|
getTradeId(): string;
|
|
setTradeId(value: string): DelayedPayoutTxSignatureResponse;
|
|
|
|
getSenderNodeAddress(): NodeAddress | undefined;
|
|
setSenderNodeAddress(value?: NodeAddress): DelayedPayoutTxSignatureResponse;
|
|
hasSenderNodeAddress(): boolean;
|
|
clearSenderNodeAddress(): DelayedPayoutTxSignatureResponse;
|
|
|
|
getDelayedPayoutTxBuyerSignature(): Uint8Array | string;
|
|
getDelayedPayoutTxBuyerSignature_asU8(): Uint8Array;
|
|
getDelayedPayoutTxBuyerSignature_asB64(): string;
|
|
setDelayedPayoutTxBuyerSignature(value: Uint8Array | string): DelayedPayoutTxSignatureResponse;
|
|
|
|
getDepositTx(): Uint8Array | string;
|
|
getDepositTx_asU8(): Uint8Array;
|
|
getDepositTx_asB64(): string;
|
|
setDepositTx(value: Uint8Array | string): DelayedPayoutTxSignatureResponse;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): DelayedPayoutTxSignatureResponse.AsObject;
|
|
static toObject(includeInstance: boolean, msg: DelayedPayoutTxSignatureResponse): DelayedPayoutTxSignatureResponse.AsObject;
|
|
static serializeBinaryToWriter(message: DelayedPayoutTxSignatureResponse, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): DelayedPayoutTxSignatureResponse;
|
|
static deserializeBinaryFromReader(message: DelayedPayoutTxSignatureResponse, reader: jspb.BinaryReader): DelayedPayoutTxSignatureResponse;
|
|
}
|
|
|
|
export namespace DelayedPayoutTxSignatureResponse {
|
|
export type AsObject = {
|
|
uid: string,
|
|
tradeId: string,
|
|
senderNodeAddress?: NodeAddress.AsObject,
|
|
delayedPayoutTxBuyerSignature: Uint8Array | string,
|
|
depositTx: Uint8Array | string,
|
|
}
|
|
}
|
|
|
|
export class DepositTxAndDelayedPayoutTxMessage extends jspb.Message {
|
|
getUid(): string;
|
|
setUid(value: string): DepositTxAndDelayedPayoutTxMessage;
|
|
|
|
getTradeId(): string;
|
|
setTradeId(value: string): DepositTxAndDelayedPayoutTxMessage;
|
|
|
|
getSenderNodeAddress(): NodeAddress | undefined;
|
|
setSenderNodeAddress(value?: NodeAddress): DepositTxAndDelayedPayoutTxMessage;
|
|
hasSenderNodeAddress(): boolean;
|
|
clearSenderNodeAddress(): DepositTxAndDelayedPayoutTxMessage;
|
|
|
|
getDepositTx(): Uint8Array | string;
|
|
getDepositTx_asU8(): Uint8Array;
|
|
getDepositTx_asB64(): string;
|
|
setDepositTx(value: Uint8Array | string): DepositTxAndDelayedPayoutTxMessage;
|
|
|
|
getDelayedPayoutTx(): Uint8Array | string;
|
|
getDelayedPayoutTx_asU8(): Uint8Array;
|
|
getDelayedPayoutTx_asB64(): string;
|
|
setDelayedPayoutTx(value: Uint8Array | string): DepositTxAndDelayedPayoutTxMessage;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): DepositTxAndDelayedPayoutTxMessage.AsObject;
|
|
static toObject(includeInstance: boolean, msg: DepositTxAndDelayedPayoutTxMessage): DepositTxAndDelayedPayoutTxMessage.AsObject;
|
|
static serializeBinaryToWriter(message: DepositTxAndDelayedPayoutTxMessage, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): DepositTxAndDelayedPayoutTxMessage;
|
|
static deserializeBinaryFromReader(message: DepositTxAndDelayedPayoutTxMessage, reader: jspb.BinaryReader): DepositTxAndDelayedPayoutTxMessage;
|
|
}
|
|
|
|
export namespace DepositTxAndDelayedPayoutTxMessage {
|
|
export type AsObject = {
|
|
uid: string,
|
|
tradeId: string,
|
|
senderNodeAddress?: NodeAddress.AsObject,
|
|
depositTx: Uint8Array | string,
|
|
delayedPayoutTx: Uint8Array | string,
|
|
}
|
|
}
|
|
|
|
export class DepositTxMessage extends jspb.Message {
|
|
getUid(): string;
|
|
setUid(value: string): DepositTxMessage;
|
|
|
|
getTradeId(): string;
|
|
setTradeId(value: string): DepositTxMessage;
|
|
|
|
getSenderNodeAddress(): NodeAddress | undefined;
|
|
setSenderNodeAddress(value?: NodeAddress): DepositTxMessage;
|
|
hasSenderNodeAddress(): boolean;
|
|
clearSenderNodeAddress(): DepositTxMessage;
|
|
|
|
getDepositTxWithoutWitnesses(): Uint8Array | string;
|
|
getDepositTxWithoutWitnesses_asU8(): Uint8Array;
|
|
getDepositTxWithoutWitnesses_asB64(): string;
|
|
setDepositTxWithoutWitnesses(value: Uint8Array | string): DepositTxMessage;
|
|
|
|
getPubKeyRing(): PubKeyRing | undefined;
|
|
setPubKeyRing(value?: PubKeyRing): DepositTxMessage;
|
|
hasPubKeyRing(): boolean;
|
|
clearPubKeyRing(): DepositTxMessage;
|
|
|
|
getTradeFeeTxId(): string;
|
|
setTradeFeeTxId(value: string): DepositTxMessage;
|
|
|
|
getDepositTxId(): string;
|
|
setDepositTxId(value: string): DepositTxMessage;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): DepositTxMessage.AsObject;
|
|
static toObject(includeInstance: boolean, msg: DepositTxMessage): DepositTxMessage.AsObject;
|
|
static serializeBinaryToWriter(message: DepositTxMessage, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): DepositTxMessage;
|
|
static deserializeBinaryFromReader(message: DepositTxMessage, reader: jspb.BinaryReader): DepositTxMessage;
|
|
}
|
|
|
|
export namespace DepositTxMessage {
|
|
export type AsObject = {
|
|
uid: string,
|
|
tradeId: string,
|
|
senderNodeAddress?: NodeAddress.AsObject,
|
|
depositTxWithoutWitnesses: Uint8Array | string,
|
|
pubKeyRing?: PubKeyRing.AsObject,
|
|
tradeFeeTxId: string,
|
|
depositTxId: string,
|
|
}
|
|
}
|
|
|
|
export class PeerPublishedDelayedPayoutTxMessage extends jspb.Message {
|
|
getUid(): string;
|
|
setUid(value: string): PeerPublishedDelayedPayoutTxMessage;
|
|
|
|
getTradeId(): string;
|
|
setTradeId(value: string): PeerPublishedDelayedPayoutTxMessage;
|
|
|
|
getSenderNodeAddress(): NodeAddress | undefined;
|
|
setSenderNodeAddress(value?: NodeAddress): PeerPublishedDelayedPayoutTxMessage;
|
|
hasSenderNodeAddress(): boolean;
|
|
clearSenderNodeAddress(): PeerPublishedDelayedPayoutTxMessage;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PeerPublishedDelayedPayoutTxMessage.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PeerPublishedDelayedPayoutTxMessage): PeerPublishedDelayedPayoutTxMessage.AsObject;
|
|
static serializeBinaryToWriter(message: PeerPublishedDelayedPayoutTxMessage, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PeerPublishedDelayedPayoutTxMessage;
|
|
static deserializeBinaryFromReader(message: PeerPublishedDelayedPayoutTxMessage, reader: jspb.BinaryReader): PeerPublishedDelayedPayoutTxMessage;
|
|
}
|
|
|
|
export namespace PeerPublishedDelayedPayoutTxMessage {
|
|
export type AsObject = {
|
|
uid: string,
|
|
tradeId: string,
|
|
senderNodeAddress?: NodeAddress.AsObject,
|
|
}
|
|
}
|
|
|
|
export class PaymentSentMessage extends jspb.Message {
|
|
getTradeId(): string;
|
|
setTradeId(value: string): PaymentSentMessage;
|
|
|
|
getSenderNodeAddress(): NodeAddress | undefined;
|
|
setSenderNodeAddress(value?: NodeAddress): PaymentSentMessage;
|
|
hasSenderNodeAddress(): boolean;
|
|
clearSenderNodeAddress(): PaymentSentMessage;
|
|
|
|
getCounterCurrencyTxId(): string;
|
|
setCounterCurrencyTxId(value: string): PaymentSentMessage;
|
|
|
|
getUid(): string;
|
|
setUid(value: string): PaymentSentMessage;
|
|
|
|
getCounterCurrencyExtraData(): string;
|
|
setCounterCurrencyExtraData(value: string): PaymentSentMessage;
|
|
|
|
getPayoutTxHex(): string;
|
|
setPayoutTxHex(value: string): PaymentSentMessage;
|
|
|
|
getUpdatedMultisigHex(): string;
|
|
setUpdatedMultisigHex(value: string): PaymentSentMessage;
|
|
|
|
getPaymentAccountKey(): Uint8Array | string;
|
|
getPaymentAccountKey_asU8(): Uint8Array;
|
|
getPaymentAccountKey_asB64(): string;
|
|
setPaymentAccountKey(value: Uint8Array | string): PaymentSentMessage;
|
|
|
|
getSellerAccountAgeWitness(): AccountAgeWitness | undefined;
|
|
setSellerAccountAgeWitness(value?: AccountAgeWitness): PaymentSentMessage;
|
|
hasSellerAccountAgeWitness(): boolean;
|
|
clearSellerAccountAgeWitness(): PaymentSentMessage;
|
|
|
|
getBuyerSignature(): Uint8Array | string;
|
|
getBuyerSignature_asU8(): Uint8Array;
|
|
getBuyerSignature_asB64(): string;
|
|
setBuyerSignature(value: Uint8Array | string): PaymentSentMessage;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PaymentSentMessage.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PaymentSentMessage): PaymentSentMessage.AsObject;
|
|
static serializeBinaryToWriter(message: PaymentSentMessage, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PaymentSentMessage;
|
|
static deserializeBinaryFromReader(message: PaymentSentMessage, reader: jspb.BinaryReader): PaymentSentMessage;
|
|
}
|
|
|
|
export namespace PaymentSentMessage {
|
|
export type AsObject = {
|
|
tradeId: string,
|
|
senderNodeAddress?: NodeAddress.AsObject,
|
|
counterCurrencyTxId: string,
|
|
uid: string,
|
|
counterCurrencyExtraData: string,
|
|
payoutTxHex: string,
|
|
updatedMultisigHex: string,
|
|
paymentAccountKey: Uint8Array | string,
|
|
sellerAccountAgeWitness?: AccountAgeWitness.AsObject,
|
|
buyerSignature: Uint8Array | string,
|
|
}
|
|
}
|
|
|
|
export class PaymentReceivedMessage extends jspb.Message {
|
|
getTradeId(): string;
|
|
setTradeId(value: string): PaymentReceivedMessage;
|
|
|
|
getSenderNodeAddress(): NodeAddress | undefined;
|
|
setSenderNodeAddress(value?: NodeAddress): PaymentReceivedMessage;
|
|
hasSenderNodeAddress(): boolean;
|
|
clearSenderNodeAddress(): PaymentReceivedMessage;
|
|
|
|
getUid(): string;
|
|
setUid(value: string): PaymentReceivedMessage;
|
|
|
|
getUnsignedPayoutTxHex(): string;
|
|
setUnsignedPayoutTxHex(value: string): PaymentReceivedMessage;
|
|
|
|
getSignedPayoutTxHex(): string;
|
|
setSignedPayoutTxHex(value: string): PaymentReceivedMessage;
|
|
|
|
getUpdatedMultisigHex(): string;
|
|
setUpdatedMultisigHex(value: string): PaymentReceivedMessage;
|
|
|
|
getDeferPublishPayout(): boolean;
|
|
setDeferPublishPayout(value: boolean): PaymentReceivedMessage;
|
|
|
|
getBuyerAccountAgeWitness(): AccountAgeWitness | undefined;
|
|
setBuyerAccountAgeWitness(value?: AccountAgeWitness): PaymentReceivedMessage;
|
|
hasBuyerAccountAgeWitness(): boolean;
|
|
clearBuyerAccountAgeWitness(): PaymentReceivedMessage;
|
|
|
|
getBuyerSignedWitness(): SignedWitness | undefined;
|
|
setBuyerSignedWitness(value?: SignedWitness): PaymentReceivedMessage;
|
|
hasBuyerSignedWitness(): boolean;
|
|
clearBuyerSignedWitness(): PaymentReceivedMessage;
|
|
|
|
getPaymentSentMessage(): PaymentSentMessage | undefined;
|
|
setPaymentSentMessage(value?: PaymentSentMessage): PaymentReceivedMessage;
|
|
hasPaymentSentMessage(): boolean;
|
|
clearPaymentSentMessage(): PaymentReceivedMessage;
|
|
|
|
getSellerSignature(): Uint8Array | string;
|
|
getSellerSignature_asU8(): Uint8Array;
|
|
getSellerSignature_asB64(): string;
|
|
setSellerSignature(value: Uint8Array | string): PaymentReceivedMessage;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PaymentReceivedMessage.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PaymentReceivedMessage): PaymentReceivedMessage.AsObject;
|
|
static serializeBinaryToWriter(message: PaymentReceivedMessage, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PaymentReceivedMessage;
|
|
static deserializeBinaryFromReader(message: PaymentReceivedMessage, reader: jspb.BinaryReader): PaymentReceivedMessage;
|
|
}
|
|
|
|
export namespace PaymentReceivedMessage {
|
|
export type AsObject = {
|
|
tradeId: string,
|
|
senderNodeAddress?: NodeAddress.AsObject,
|
|
uid: string,
|
|
unsignedPayoutTxHex: string,
|
|
signedPayoutTxHex: string,
|
|
updatedMultisigHex: string,
|
|
deferPublishPayout: boolean,
|
|
buyerAccountAgeWitness?: AccountAgeWitness.AsObject,
|
|
buyerSignedWitness?: SignedWitness.AsObject,
|
|
paymentSentMessage?: PaymentSentMessage.AsObject,
|
|
sellerSignature: Uint8Array | string,
|
|
}
|
|
}
|
|
|
|
export class MediatedPayoutTxPublishedMessage extends jspb.Message {
|
|
getTradeId(): string;
|
|
setTradeId(value: string): MediatedPayoutTxPublishedMessage;
|
|
|
|
getPayoutTx(): Uint8Array | string;
|
|
getPayoutTx_asU8(): Uint8Array;
|
|
getPayoutTx_asB64(): string;
|
|
setPayoutTx(value: Uint8Array | string): MediatedPayoutTxPublishedMessage;
|
|
|
|
getSenderNodeAddress(): NodeAddress | undefined;
|
|
setSenderNodeAddress(value?: NodeAddress): MediatedPayoutTxPublishedMessage;
|
|
hasSenderNodeAddress(): boolean;
|
|
clearSenderNodeAddress(): MediatedPayoutTxPublishedMessage;
|
|
|
|
getUid(): string;
|
|
setUid(value: string): MediatedPayoutTxPublishedMessage;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): MediatedPayoutTxPublishedMessage.AsObject;
|
|
static toObject(includeInstance: boolean, msg: MediatedPayoutTxPublishedMessage): MediatedPayoutTxPublishedMessage.AsObject;
|
|
static serializeBinaryToWriter(message: MediatedPayoutTxPublishedMessage, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): MediatedPayoutTxPublishedMessage;
|
|
static deserializeBinaryFromReader(message: MediatedPayoutTxPublishedMessage, reader: jspb.BinaryReader): MediatedPayoutTxPublishedMessage;
|
|
}
|
|
|
|
export namespace MediatedPayoutTxPublishedMessage {
|
|
export type AsObject = {
|
|
tradeId: string,
|
|
payoutTx: Uint8Array | string,
|
|
senderNodeAddress?: NodeAddress.AsObject,
|
|
uid: string,
|
|
}
|
|
}
|
|
|
|
export class MediatedPayoutTxSignatureMessage extends jspb.Message {
|
|
getUid(): string;
|
|
setUid(value: string): MediatedPayoutTxSignatureMessage;
|
|
|
|
getTradeId(): string;
|
|
setTradeId(value: string): MediatedPayoutTxSignatureMessage;
|
|
|
|
getTxSignature(): Uint8Array | string;
|
|
getTxSignature_asU8(): Uint8Array;
|
|
getTxSignature_asB64(): string;
|
|
setTxSignature(value: Uint8Array | string): MediatedPayoutTxSignatureMessage;
|
|
|
|
getSenderNodeAddress(): NodeAddress | undefined;
|
|
setSenderNodeAddress(value?: NodeAddress): MediatedPayoutTxSignatureMessage;
|
|
hasSenderNodeAddress(): boolean;
|
|
clearSenderNodeAddress(): MediatedPayoutTxSignatureMessage;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): MediatedPayoutTxSignatureMessage.AsObject;
|
|
static toObject(includeInstance: boolean, msg: MediatedPayoutTxSignatureMessage): MediatedPayoutTxSignatureMessage.AsObject;
|
|
static serializeBinaryToWriter(message: MediatedPayoutTxSignatureMessage, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): MediatedPayoutTxSignatureMessage;
|
|
static deserializeBinaryFromReader(message: MediatedPayoutTxSignatureMessage, reader: jspb.BinaryReader): MediatedPayoutTxSignatureMessage;
|
|
}
|
|
|
|
export namespace MediatedPayoutTxSignatureMessage {
|
|
export type AsObject = {
|
|
uid: string,
|
|
tradeId: string,
|
|
txSignature: Uint8Array | string,
|
|
senderNodeAddress?: NodeAddress.AsObject,
|
|
}
|
|
}
|
|
|
|
export class RefreshTradeStateRequest extends jspb.Message {
|
|
getUid(): string;
|
|
setUid(value: string): RefreshTradeStateRequest;
|
|
|
|
getTradeId(): string;
|
|
setTradeId(value: string): RefreshTradeStateRequest;
|
|
|
|
getSenderNodeAddress(): NodeAddress | undefined;
|
|
setSenderNodeAddress(value?: NodeAddress): RefreshTradeStateRequest;
|
|
hasSenderNodeAddress(): boolean;
|
|
clearSenderNodeAddress(): RefreshTradeStateRequest;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): RefreshTradeStateRequest.AsObject;
|
|
static toObject(includeInstance: boolean, msg: RefreshTradeStateRequest): RefreshTradeStateRequest.AsObject;
|
|
static serializeBinaryToWriter(message: RefreshTradeStateRequest, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): RefreshTradeStateRequest;
|
|
static deserializeBinaryFromReader(message: RefreshTradeStateRequest, reader: jspb.BinaryReader): RefreshTradeStateRequest;
|
|
}
|
|
|
|
export namespace RefreshTradeStateRequest {
|
|
export type AsObject = {
|
|
uid: string,
|
|
tradeId: string,
|
|
senderNodeAddress?: NodeAddress.AsObject,
|
|
}
|
|
}
|
|
|
|
export class ChatMessage extends jspb.Message {
|
|
getDate(): number;
|
|
setDate(value: number): ChatMessage;
|
|
|
|
getTradeId(): string;
|
|
setTradeId(value: string): ChatMessage;
|
|
|
|
getTraderId(): number;
|
|
setTraderId(value: number): ChatMessage;
|
|
|
|
getSenderIsTrader(): boolean;
|
|
setSenderIsTrader(value: boolean): ChatMessage;
|
|
|
|
getMessage(): string;
|
|
setMessage(value: string): ChatMessage;
|
|
|
|
getAttachmentsList(): Array<Attachment>;
|
|
setAttachmentsList(value: Array<Attachment>): ChatMessage;
|
|
clearAttachmentsList(): ChatMessage;
|
|
addAttachments(value?: Attachment, index?: number): Attachment;
|
|
|
|
getArrived(): boolean;
|
|
setArrived(value: boolean): ChatMessage;
|
|
|
|
getStoredInMailbox(): boolean;
|
|
setStoredInMailbox(value: boolean): ChatMessage;
|
|
|
|
getIsSystemMessage(): boolean;
|
|
setIsSystemMessage(value: boolean): ChatMessage;
|
|
|
|
getSenderNodeAddress(): NodeAddress | undefined;
|
|
setSenderNodeAddress(value?: NodeAddress): ChatMessage;
|
|
hasSenderNodeAddress(): boolean;
|
|
clearSenderNodeAddress(): ChatMessage;
|
|
|
|
getUid(): string;
|
|
setUid(value: string): ChatMessage;
|
|
|
|
getSendMessageError(): string;
|
|
setSendMessageError(value: string): ChatMessage;
|
|
|
|
getAcknowledged(): boolean;
|
|
setAcknowledged(value: boolean): ChatMessage;
|
|
|
|
getAckError(): string;
|
|
setAckError(value: string): ChatMessage;
|
|
|
|
getType(): SupportType;
|
|
setType(value: SupportType): ChatMessage;
|
|
|
|
getWasDisplayed(): boolean;
|
|
setWasDisplayed(value: boolean): ChatMessage;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): ChatMessage.AsObject;
|
|
static toObject(includeInstance: boolean, msg: ChatMessage): ChatMessage.AsObject;
|
|
static serializeBinaryToWriter(message: ChatMessage, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): ChatMessage;
|
|
static deserializeBinaryFromReader(message: ChatMessage, reader: jspb.BinaryReader): ChatMessage;
|
|
}
|
|
|
|
export namespace ChatMessage {
|
|
export type AsObject = {
|
|
date: number,
|
|
tradeId: string,
|
|
traderId: number,
|
|
senderIsTrader: boolean,
|
|
message: string,
|
|
attachmentsList: Array<Attachment.AsObject>,
|
|
arrived: boolean,
|
|
storedInMailbox: boolean,
|
|
isSystemMessage: boolean,
|
|
senderNodeAddress?: NodeAddress.AsObject,
|
|
uid: string,
|
|
sendMessageError: string,
|
|
acknowledged: boolean,
|
|
ackError: string,
|
|
type: SupportType,
|
|
wasDisplayed: boolean,
|
|
}
|
|
}
|
|
|
|
export class DisputeOpenedMessage extends jspb.Message {
|
|
getDispute(): Dispute | undefined;
|
|
setDispute(value?: Dispute): DisputeOpenedMessage;
|
|
hasDispute(): boolean;
|
|
clearDispute(): DisputeOpenedMessage;
|
|
|
|
getSenderNodeAddress(): NodeAddress | undefined;
|
|
setSenderNodeAddress(value?: NodeAddress): DisputeOpenedMessage;
|
|
hasSenderNodeAddress(): boolean;
|
|
clearSenderNodeAddress(): DisputeOpenedMessage;
|
|
|
|
getUid(): string;
|
|
setUid(value: string): DisputeOpenedMessage;
|
|
|
|
getType(): SupportType;
|
|
setType(value: SupportType): DisputeOpenedMessage;
|
|
|
|
getUpdatedMultisigHex(): string;
|
|
setUpdatedMultisigHex(value: string): DisputeOpenedMessage;
|
|
|
|
getPaymentSentMessage(): PaymentSentMessage | undefined;
|
|
setPaymentSentMessage(value?: PaymentSentMessage): DisputeOpenedMessage;
|
|
hasPaymentSentMessage(): boolean;
|
|
clearPaymentSentMessage(): DisputeOpenedMessage;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): DisputeOpenedMessage.AsObject;
|
|
static toObject(includeInstance: boolean, msg: DisputeOpenedMessage): DisputeOpenedMessage.AsObject;
|
|
static serializeBinaryToWriter(message: DisputeOpenedMessage, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): DisputeOpenedMessage;
|
|
static deserializeBinaryFromReader(message: DisputeOpenedMessage, reader: jspb.BinaryReader): DisputeOpenedMessage;
|
|
}
|
|
|
|
export namespace DisputeOpenedMessage {
|
|
export type AsObject = {
|
|
dispute?: Dispute.AsObject,
|
|
senderNodeAddress?: NodeAddress.AsObject,
|
|
uid: string,
|
|
type: SupportType,
|
|
updatedMultisigHex: string,
|
|
paymentSentMessage?: PaymentSentMessage.AsObject,
|
|
}
|
|
}
|
|
|
|
export class DisputeClosedMessage extends jspb.Message {
|
|
getUid(): string;
|
|
setUid(value: string): DisputeClosedMessage;
|
|
|
|
getDisputeResult(): DisputeResult | undefined;
|
|
setDisputeResult(value?: DisputeResult): DisputeClosedMessage;
|
|
hasDisputeResult(): boolean;
|
|
clearDisputeResult(): DisputeClosedMessage;
|
|
|
|
getSenderNodeAddress(): NodeAddress | undefined;
|
|
setSenderNodeAddress(value?: NodeAddress): DisputeClosedMessage;
|
|
hasSenderNodeAddress(): boolean;
|
|
clearSenderNodeAddress(): DisputeClosedMessage;
|
|
|
|
getType(): SupportType;
|
|
setType(value: SupportType): DisputeClosedMessage;
|
|
|
|
getUpdatedMultisigHex(): string;
|
|
setUpdatedMultisigHex(value: string): DisputeClosedMessage;
|
|
|
|
getUnsignedPayoutTxHex(): string;
|
|
setUnsignedPayoutTxHex(value: string): DisputeClosedMessage;
|
|
|
|
getDeferPublishPayout(): boolean;
|
|
setDeferPublishPayout(value: boolean): DisputeClosedMessage;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): DisputeClosedMessage.AsObject;
|
|
static toObject(includeInstance: boolean, msg: DisputeClosedMessage): DisputeClosedMessage.AsObject;
|
|
static serializeBinaryToWriter(message: DisputeClosedMessage, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): DisputeClosedMessage;
|
|
static deserializeBinaryFromReader(message: DisputeClosedMessage, reader: jspb.BinaryReader): DisputeClosedMessage;
|
|
}
|
|
|
|
export namespace DisputeClosedMessage {
|
|
export type AsObject = {
|
|
uid: string,
|
|
disputeResult?: DisputeResult.AsObject,
|
|
senderNodeAddress?: NodeAddress.AsObject,
|
|
type: SupportType,
|
|
updatedMultisigHex: string,
|
|
unsignedPayoutTxHex: string,
|
|
deferPublishPayout: boolean,
|
|
}
|
|
}
|
|
|
|
export class PrivateNotificationMessage extends jspb.Message {
|
|
getUid(): string;
|
|
setUid(value: string): PrivateNotificationMessage;
|
|
|
|
getSenderNodeAddress(): NodeAddress | undefined;
|
|
setSenderNodeAddress(value?: NodeAddress): PrivateNotificationMessage;
|
|
hasSenderNodeAddress(): boolean;
|
|
clearSenderNodeAddress(): PrivateNotificationMessage;
|
|
|
|
getPrivateNotificationPayload(): PrivateNotificationPayload | undefined;
|
|
setPrivateNotificationPayload(value?: PrivateNotificationPayload): PrivateNotificationMessage;
|
|
hasPrivateNotificationPayload(): boolean;
|
|
clearPrivateNotificationPayload(): PrivateNotificationMessage;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PrivateNotificationMessage.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PrivateNotificationMessage): PrivateNotificationMessage.AsObject;
|
|
static serializeBinaryToWriter(message: PrivateNotificationMessage, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PrivateNotificationMessage;
|
|
static deserializeBinaryFromReader(message: PrivateNotificationMessage, reader: jspb.BinaryReader): PrivateNotificationMessage;
|
|
}
|
|
|
|
export namespace PrivateNotificationMessage {
|
|
export type AsObject = {
|
|
uid: string,
|
|
senderNodeAddress?: NodeAddress.AsObject,
|
|
privateNotificationPayload?: PrivateNotificationPayload.AsObject,
|
|
}
|
|
}
|
|
|
|
export class NodeAddress extends jspb.Message {
|
|
getHostName(): string;
|
|
setHostName(value: string): NodeAddress;
|
|
|
|
getPort(): number;
|
|
setPort(value: number): NodeAddress;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): NodeAddress.AsObject;
|
|
static toObject(includeInstance: boolean, msg: NodeAddress): NodeAddress.AsObject;
|
|
static serializeBinaryToWriter(message: NodeAddress, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): NodeAddress;
|
|
static deserializeBinaryFromReader(message: NodeAddress, reader: jspb.BinaryReader): NodeAddress;
|
|
}
|
|
|
|
export namespace NodeAddress {
|
|
export type AsObject = {
|
|
hostName: string,
|
|
port: number,
|
|
}
|
|
}
|
|
|
|
export class Peer extends jspb.Message {
|
|
getNodeAddress(): NodeAddress | undefined;
|
|
setNodeAddress(value?: NodeAddress): Peer;
|
|
hasNodeAddress(): boolean;
|
|
clearNodeAddress(): Peer;
|
|
|
|
getDate(): number;
|
|
setDate(value: number): Peer;
|
|
|
|
getSupportedCapabilitiesList(): Array<number>;
|
|
setSupportedCapabilitiesList(value: Array<number>): Peer;
|
|
clearSupportedCapabilitiesList(): Peer;
|
|
addSupportedCapabilities(value: number, index?: number): Peer;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): Peer.AsObject;
|
|
static toObject(includeInstance: boolean, msg: Peer): Peer.AsObject;
|
|
static serializeBinaryToWriter(message: Peer, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): Peer;
|
|
static deserializeBinaryFromReader(message: Peer, reader: jspb.BinaryReader): Peer;
|
|
}
|
|
|
|
export namespace Peer {
|
|
export type AsObject = {
|
|
nodeAddress?: NodeAddress.AsObject,
|
|
date: number,
|
|
supportedCapabilitiesList: Array<number>,
|
|
}
|
|
}
|
|
|
|
export class PubKeyRing extends jspb.Message {
|
|
getSignaturePubKeyBytes(): Uint8Array | string;
|
|
getSignaturePubKeyBytes_asU8(): Uint8Array;
|
|
getSignaturePubKeyBytes_asB64(): string;
|
|
setSignaturePubKeyBytes(value: Uint8Array | string): PubKeyRing;
|
|
|
|
getEncryptionPubKeyBytes(): Uint8Array | string;
|
|
getEncryptionPubKeyBytes_asU8(): Uint8Array;
|
|
getEncryptionPubKeyBytes_asB64(): string;
|
|
setEncryptionPubKeyBytes(value: Uint8Array | string): PubKeyRing;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PubKeyRing.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PubKeyRing): PubKeyRing.AsObject;
|
|
static serializeBinaryToWriter(message: PubKeyRing, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PubKeyRing;
|
|
static deserializeBinaryFromReader(message: PubKeyRing, reader: jspb.BinaryReader): PubKeyRing;
|
|
}
|
|
|
|
export namespace PubKeyRing {
|
|
export type AsObject = {
|
|
signaturePubKeyBytes: Uint8Array | string,
|
|
encryptionPubKeyBytes: Uint8Array | string,
|
|
}
|
|
}
|
|
|
|
export class SealedAndSigned extends jspb.Message {
|
|
getEncryptedSecretKey(): Uint8Array | string;
|
|
getEncryptedSecretKey_asU8(): Uint8Array;
|
|
getEncryptedSecretKey_asB64(): string;
|
|
setEncryptedSecretKey(value: Uint8Array | string): SealedAndSigned;
|
|
|
|
getEncryptedPayloadWithHmac(): Uint8Array | string;
|
|
getEncryptedPayloadWithHmac_asU8(): Uint8Array;
|
|
getEncryptedPayloadWithHmac_asB64(): string;
|
|
setEncryptedPayloadWithHmac(value: Uint8Array | string): SealedAndSigned;
|
|
|
|
getSignature(): Uint8Array | string;
|
|
getSignature_asU8(): Uint8Array;
|
|
getSignature_asB64(): string;
|
|
setSignature(value: Uint8Array | string): SealedAndSigned;
|
|
|
|
getSigPublicKeyBytes(): Uint8Array | string;
|
|
getSigPublicKeyBytes_asU8(): Uint8Array;
|
|
getSigPublicKeyBytes_asB64(): string;
|
|
setSigPublicKeyBytes(value: Uint8Array | string): SealedAndSigned;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): SealedAndSigned.AsObject;
|
|
static toObject(includeInstance: boolean, msg: SealedAndSigned): SealedAndSigned.AsObject;
|
|
static serializeBinaryToWriter(message: SealedAndSigned, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): SealedAndSigned;
|
|
static deserializeBinaryFromReader(message: SealedAndSigned, reader: jspb.BinaryReader): SealedAndSigned;
|
|
}
|
|
|
|
export namespace SealedAndSigned {
|
|
export type AsObject = {
|
|
encryptedSecretKey: Uint8Array | string,
|
|
encryptedPayloadWithHmac: Uint8Array | string,
|
|
signature: Uint8Array | string,
|
|
sigPublicKeyBytes: Uint8Array | string,
|
|
}
|
|
}
|
|
|
|
export class StoragePayload extends jspb.Message {
|
|
getAlert(): Alert | undefined;
|
|
setAlert(value?: Alert): StoragePayload;
|
|
hasAlert(): boolean;
|
|
clearAlert(): StoragePayload;
|
|
|
|
getArbitrator(): Arbitrator | undefined;
|
|
setArbitrator(value?: Arbitrator): StoragePayload;
|
|
hasArbitrator(): boolean;
|
|
clearArbitrator(): StoragePayload;
|
|
|
|
getMediator(): Mediator | undefined;
|
|
setMediator(value?: Mediator): StoragePayload;
|
|
hasMediator(): boolean;
|
|
clearMediator(): StoragePayload;
|
|
|
|
getFilter(): Filter | undefined;
|
|
setFilter(value?: Filter): StoragePayload;
|
|
hasFilter(): boolean;
|
|
clearFilter(): StoragePayload;
|
|
|
|
getMailboxStoragePayload(): MailboxStoragePayload | undefined;
|
|
setMailboxStoragePayload(value?: MailboxStoragePayload): StoragePayload;
|
|
hasMailboxStoragePayload(): boolean;
|
|
clearMailboxStoragePayload(): StoragePayload;
|
|
|
|
getOfferPayload(): OfferPayload | undefined;
|
|
setOfferPayload(value?: OfferPayload): StoragePayload;
|
|
hasOfferPayload(): boolean;
|
|
clearOfferPayload(): StoragePayload;
|
|
|
|
getRefundAgent(): RefundAgent | undefined;
|
|
setRefundAgent(value?: RefundAgent): StoragePayload;
|
|
hasRefundAgent(): boolean;
|
|
clearRefundAgent(): StoragePayload;
|
|
|
|
getMessageCase(): StoragePayload.MessageCase;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): StoragePayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: StoragePayload): StoragePayload.AsObject;
|
|
static serializeBinaryToWriter(message: StoragePayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): StoragePayload;
|
|
static deserializeBinaryFromReader(message: StoragePayload, reader: jspb.BinaryReader): StoragePayload;
|
|
}
|
|
|
|
export namespace StoragePayload {
|
|
export type AsObject = {
|
|
alert?: Alert.AsObject,
|
|
arbitrator?: Arbitrator.AsObject,
|
|
mediator?: Mediator.AsObject,
|
|
filter?: Filter.AsObject,
|
|
mailboxStoragePayload?: MailboxStoragePayload.AsObject,
|
|
offerPayload?: OfferPayload.AsObject,
|
|
refundAgent?: RefundAgent.AsObject,
|
|
}
|
|
|
|
export enum MessageCase {
|
|
MESSAGE_NOT_SET = 0,
|
|
ALERT = 1,
|
|
ARBITRATOR = 2,
|
|
MEDIATOR = 3,
|
|
FILTER = 4,
|
|
MAILBOX_STORAGE_PAYLOAD = 6,
|
|
OFFER_PAYLOAD = 7,
|
|
REFUND_AGENT = 8,
|
|
}
|
|
}
|
|
|
|
export class PersistableNetworkPayload extends jspb.Message {
|
|
getAccountAgeWitness(): AccountAgeWitness | undefined;
|
|
setAccountAgeWitness(value?: AccountAgeWitness): PersistableNetworkPayload;
|
|
hasAccountAgeWitness(): boolean;
|
|
clearAccountAgeWitness(): PersistableNetworkPayload;
|
|
|
|
getTradeStatistics2(): TradeStatistics2 | undefined;
|
|
setTradeStatistics2(value?: TradeStatistics2): PersistableNetworkPayload;
|
|
hasTradeStatistics2(): boolean;
|
|
clearTradeStatistics2(): PersistableNetworkPayload;
|
|
|
|
getSignedWitness(): SignedWitness | undefined;
|
|
setSignedWitness(value?: SignedWitness): PersistableNetworkPayload;
|
|
hasSignedWitness(): boolean;
|
|
clearSignedWitness(): PersistableNetworkPayload;
|
|
|
|
getTradeStatistics3(): TradeStatistics3 | undefined;
|
|
setTradeStatistics3(value?: TradeStatistics3): PersistableNetworkPayload;
|
|
hasTradeStatistics3(): boolean;
|
|
clearTradeStatistics3(): PersistableNetworkPayload;
|
|
|
|
getMessageCase(): PersistableNetworkPayload.MessageCase;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PersistableNetworkPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PersistableNetworkPayload): PersistableNetworkPayload.AsObject;
|
|
static serializeBinaryToWriter(message: PersistableNetworkPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PersistableNetworkPayload;
|
|
static deserializeBinaryFromReader(message: PersistableNetworkPayload, reader: jspb.BinaryReader): PersistableNetworkPayload;
|
|
}
|
|
|
|
export namespace PersistableNetworkPayload {
|
|
export type AsObject = {
|
|
accountAgeWitness?: AccountAgeWitness.AsObject,
|
|
tradeStatistics2?: TradeStatistics2.AsObject,
|
|
signedWitness?: SignedWitness.AsObject,
|
|
tradeStatistics3?: TradeStatistics3.AsObject,
|
|
}
|
|
|
|
export enum MessageCase {
|
|
MESSAGE_NOT_SET = 0,
|
|
ACCOUNT_AGE_WITNESS = 1,
|
|
TRADE_STATISTICS2 = 2,
|
|
SIGNED_WITNESS = 3,
|
|
TRADE_STATISTICS3 = 4,
|
|
}
|
|
}
|
|
|
|
export class ProtectedStorageEntry extends jspb.Message {
|
|
getStoragepayload(): StoragePayload | undefined;
|
|
setStoragepayload(value?: StoragePayload): ProtectedStorageEntry;
|
|
hasStoragepayload(): boolean;
|
|
clearStoragepayload(): ProtectedStorageEntry;
|
|
|
|
getOwnerPubKeyBytes(): Uint8Array | string;
|
|
getOwnerPubKeyBytes_asU8(): Uint8Array;
|
|
getOwnerPubKeyBytes_asB64(): string;
|
|
setOwnerPubKeyBytes(value: Uint8Array | string): ProtectedStorageEntry;
|
|
|
|
getSequenceNumber(): number;
|
|
setSequenceNumber(value: number): ProtectedStorageEntry;
|
|
|
|
getSignature(): Uint8Array | string;
|
|
getSignature_asU8(): Uint8Array;
|
|
getSignature_asB64(): string;
|
|
setSignature(value: Uint8Array | string): ProtectedStorageEntry;
|
|
|
|
getCreationTimeStamp(): number;
|
|
setCreationTimeStamp(value: number): ProtectedStorageEntry;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): ProtectedStorageEntry.AsObject;
|
|
static toObject(includeInstance: boolean, msg: ProtectedStorageEntry): ProtectedStorageEntry.AsObject;
|
|
static serializeBinaryToWriter(message: ProtectedStorageEntry, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): ProtectedStorageEntry;
|
|
static deserializeBinaryFromReader(message: ProtectedStorageEntry, reader: jspb.BinaryReader): ProtectedStorageEntry;
|
|
}
|
|
|
|
export namespace ProtectedStorageEntry {
|
|
export type AsObject = {
|
|
storagepayload?: StoragePayload.AsObject,
|
|
ownerPubKeyBytes: Uint8Array | string,
|
|
sequenceNumber: number,
|
|
signature: Uint8Array | string,
|
|
creationTimeStamp: number,
|
|
}
|
|
}
|
|
|
|
export class StorageEntryWrapper extends jspb.Message {
|
|
getProtectedStorageEntry(): ProtectedStorageEntry | undefined;
|
|
setProtectedStorageEntry(value?: ProtectedStorageEntry): StorageEntryWrapper;
|
|
hasProtectedStorageEntry(): boolean;
|
|
clearProtectedStorageEntry(): StorageEntryWrapper;
|
|
|
|
getProtectedMailboxStorageEntry(): ProtectedMailboxStorageEntry | undefined;
|
|
setProtectedMailboxStorageEntry(value?: ProtectedMailboxStorageEntry): StorageEntryWrapper;
|
|
hasProtectedMailboxStorageEntry(): boolean;
|
|
clearProtectedMailboxStorageEntry(): StorageEntryWrapper;
|
|
|
|
getMessageCase(): StorageEntryWrapper.MessageCase;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): StorageEntryWrapper.AsObject;
|
|
static toObject(includeInstance: boolean, msg: StorageEntryWrapper): StorageEntryWrapper.AsObject;
|
|
static serializeBinaryToWriter(message: StorageEntryWrapper, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): StorageEntryWrapper;
|
|
static deserializeBinaryFromReader(message: StorageEntryWrapper, reader: jspb.BinaryReader): StorageEntryWrapper;
|
|
}
|
|
|
|
export namespace StorageEntryWrapper {
|
|
export type AsObject = {
|
|
protectedStorageEntry?: ProtectedStorageEntry.AsObject,
|
|
protectedMailboxStorageEntry?: ProtectedMailboxStorageEntry.AsObject,
|
|
}
|
|
|
|
export enum MessageCase {
|
|
MESSAGE_NOT_SET = 0,
|
|
PROTECTED_STORAGE_ENTRY = 1,
|
|
PROTECTED_MAILBOX_STORAGE_ENTRY = 2,
|
|
}
|
|
}
|
|
|
|
export class ProtectedMailboxStorageEntry extends jspb.Message {
|
|
getEntry(): ProtectedStorageEntry | undefined;
|
|
setEntry(value?: ProtectedStorageEntry): ProtectedMailboxStorageEntry;
|
|
hasEntry(): boolean;
|
|
clearEntry(): ProtectedMailboxStorageEntry;
|
|
|
|
getReceiversPubKeyBytes(): Uint8Array | string;
|
|
getReceiversPubKeyBytes_asU8(): Uint8Array;
|
|
getReceiversPubKeyBytes_asB64(): string;
|
|
setReceiversPubKeyBytes(value: Uint8Array | string): ProtectedMailboxStorageEntry;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): ProtectedMailboxStorageEntry.AsObject;
|
|
static toObject(includeInstance: boolean, msg: ProtectedMailboxStorageEntry): ProtectedMailboxStorageEntry.AsObject;
|
|
static serializeBinaryToWriter(message: ProtectedMailboxStorageEntry, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): ProtectedMailboxStorageEntry;
|
|
static deserializeBinaryFromReader(message: ProtectedMailboxStorageEntry, reader: jspb.BinaryReader): ProtectedMailboxStorageEntry;
|
|
}
|
|
|
|
export namespace ProtectedMailboxStorageEntry {
|
|
export type AsObject = {
|
|
entry?: ProtectedStorageEntry.AsObject,
|
|
receiversPubKeyBytes: Uint8Array | string,
|
|
}
|
|
}
|
|
|
|
export class DataAndSeqNrPair extends jspb.Message {
|
|
getPayload(): StoragePayload | undefined;
|
|
setPayload(value?: StoragePayload): DataAndSeqNrPair;
|
|
hasPayload(): boolean;
|
|
clearPayload(): DataAndSeqNrPair;
|
|
|
|
getSequenceNumber(): number;
|
|
setSequenceNumber(value: number): DataAndSeqNrPair;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): DataAndSeqNrPair.AsObject;
|
|
static toObject(includeInstance: boolean, msg: DataAndSeqNrPair): DataAndSeqNrPair.AsObject;
|
|
static serializeBinaryToWriter(message: DataAndSeqNrPair, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): DataAndSeqNrPair;
|
|
static deserializeBinaryFromReader(message: DataAndSeqNrPair, reader: jspb.BinaryReader): DataAndSeqNrPair;
|
|
}
|
|
|
|
export namespace DataAndSeqNrPair {
|
|
export type AsObject = {
|
|
payload?: StoragePayload.AsObject,
|
|
sequenceNumber: number,
|
|
}
|
|
}
|
|
|
|
export class MailboxMessageList extends jspb.Message {
|
|
getMailboxItemList(): Array<MailboxItem>;
|
|
setMailboxItemList(value: Array<MailboxItem>): MailboxMessageList;
|
|
clearMailboxItemList(): MailboxMessageList;
|
|
addMailboxItem(value?: MailboxItem, index?: number): MailboxItem;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): MailboxMessageList.AsObject;
|
|
static toObject(includeInstance: boolean, msg: MailboxMessageList): MailboxMessageList.AsObject;
|
|
static serializeBinaryToWriter(message: MailboxMessageList, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): MailboxMessageList;
|
|
static deserializeBinaryFromReader(message: MailboxMessageList, reader: jspb.BinaryReader): MailboxMessageList;
|
|
}
|
|
|
|
export namespace MailboxMessageList {
|
|
export type AsObject = {
|
|
mailboxItemList: Array<MailboxItem.AsObject>,
|
|
}
|
|
}
|
|
|
|
export class RemovedPayloadsMap extends jspb.Message {
|
|
getDateByHashesMap(): jspb.Map<string, number>;
|
|
clearDateByHashesMap(): RemovedPayloadsMap;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): RemovedPayloadsMap.AsObject;
|
|
static toObject(includeInstance: boolean, msg: RemovedPayloadsMap): RemovedPayloadsMap.AsObject;
|
|
static serializeBinaryToWriter(message: RemovedPayloadsMap, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): RemovedPayloadsMap;
|
|
static deserializeBinaryFromReader(message: RemovedPayloadsMap, reader: jspb.BinaryReader): RemovedPayloadsMap;
|
|
}
|
|
|
|
export namespace RemovedPayloadsMap {
|
|
export type AsObject = {
|
|
dateByHashesMap: Array<[string, number]>,
|
|
}
|
|
}
|
|
|
|
export class IgnoredMailboxMap extends jspb.Message {
|
|
getDataMap(): jspb.Map<string, number>;
|
|
clearDataMap(): IgnoredMailboxMap;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): IgnoredMailboxMap.AsObject;
|
|
static toObject(includeInstance: boolean, msg: IgnoredMailboxMap): IgnoredMailboxMap.AsObject;
|
|
static serializeBinaryToWriter(message: IgnoredMailboxMap, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): IgnoredMailboxMap;
|
|
static deserializeBinaryFromReader(message: IgnoredMailboxMap, reader: jspb.BinaryReader): IgnoredMailboxMap;
|
|
}
|
|
|
|
export namespace IgnoredMailboxMap {
|
|
export type AsObject = {
|
|
dataMap: Array<[string, number]>,
|
|
}
|
|
}
|
|
|
|
export class MailboxItem extends jspb.Message {
|
|
getProtectedMailboxStorageEntry(): ProtectedMailboxStorageEntry | undefined;
|
|
setProtectedMailboxStorageEntry(value?: ProtectedMailboxStorageEntry): MailboxItem;
|
|
hasProtectedMailboxStorageEntry(): boolean;
|
|
clearProtectedMailboxStorageEntry(): MailboxItem;
|
|
|
|
getDecryptedMessageWithPubKey(): DecryptedMessageWithPubKey | undefined;
|
|
setDecryptedMessageWithPubKey(value?: DecryptedMessageWithPubKey): MailboxItem;
|
|
hasDecryptedMessageWithPubKey(): boolean;
|
|
clearDecryptedMessageWithPubKey(): MailboxItem;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): MailboxItem.AsObject;
|
|
static toObject(includeInstance: boolean, msg: MailboxItem): MailboxItem.AsObject;
|
|
static serializeBinaryToWriter(message: MailboxItem, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): MailboxItem;
|
|
static deserializeBinaryFromReader(message: MailboxItem, reader: jspb.BinaryReader): MailboxItem;
|
|
}
|
|
|
|
export namespace MailboxItem {
|
|
export type AsObject = {
|
|
protectedMailboxStorageEntry?: ProtectedMailboxStorageEntry.AsObject,
|
|
decryptedMessageWithPubKey?: DecryptedMessageWithPubKey.AsObject,
|
|
}
|
|
}
|
|
|
|
export class DecryptedMessageWithPubKey extends jspb.Message {
|
|
getNetworkEnvelope(): NetworkEnvelope | undefined;
|
|
setNetworkEnvelope(value?: NetworkEnvelope): DecryptedMessageWithPubKey;
|
|
hasNetworkEnvelope(): boolean;
|
|
clearNetworkEnvelope(): DecryptedMessageWithPubKey;
|
|
|
|
getSignaturePubKeyBytes(): Uint8Array | string;
|
|
getSignaturePubKeyBytes_asU8(): Uint8Array;
|
|
getSignaturePubKeyBytes_asB64(): string;
|
|
setSignaturePubKeyBytes(value: Uint8Array | string): DecryptedMessageWithPubKey;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): DecryptedMessageWithPubKey.AsObject;
|
|
static toObject(includeInstance: boolean, msg: DecryptedMessageWithPubKey): DecryptedMessageWithPubKey.AsObject;
|
|
static serializeBinaryToWriter(message: DecryptedMessageWithPubKey, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): DecryptedMessageWithPubKey;
|
|
static deserializeBinaryFromReader(message: DecryptedMessageWithPubKey, reader: jspb.BinaryReader): DecryptedMessageWithPubKey;
|
|
}
|
|
|
|
export namespace DecryptedMessageWithPubKey {
|
|
export type AsObject = {
|
|
networkEnvelope?: NetworkEnvelope.AsObject,
|
|
signaturePubKeyBytes: Uint8Array | string,
|
|
}
|
|
}
|
|
|
|
export class PrivateNotificationPayload extends jspb.Message {
|
|
getMessage(): string;
|
|
setMessage(value: string): PrivateNotificationPayload;
|
|
|
|
getSignatureAsBase64(): string;
|
|
setSignatureAsBase64(value: string): PrivateNotificationPayload;
|
|
|
|
getSigPublicKeyBytes(): Uint8Array | string;
|
|
getSigPublicKeyBytes_asU8(): Uint8Array;
|
|
getSigPublicKeyBytes_asB64(): string;
|
|
setSigPublicKeyBytes(value: Uint8Array | string): PrivateNotificationPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PrivateNotificationPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PrivateNotificationPayload): PrivateNotificationPayload.AsObject;
|
|
static serializeBinaryToWriter(message: PrivateNotificationPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PrivateNotificationPayload;
|
|
static deserializeBinaryFromReader(message: PrivateNotificationPayload, reader: jspb.BinaryReader): PrivateNotificationPayload;
|
|
}
|
|
|
|
export namespace PrivateNotificationPayload {
|
|
export type AsObject = {
|
|
message: string,
|
|
signatureAsBase64: string,
|
|
sigPublicKeyBytes: Uint8Array | string,
|
|
}
|
|
}
|
|
|
|
export class PaymentAccountFilter extends jspb.Message {
|
|
getPaymentMethodId(): string;
|
|
setPaymentMethodId(value: string): PaymentAccountFilter;
|
|
|
|
getGetMethodName(): string;
|
|
setGetMethodName(value: string): PaymentAccountFilter;
|
|
|
|
getValue(): string;
|
|
setValue(value: string): PaymentAccountFilter;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PaymentAccountFilter.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PaymentAccountFilter): PaymentAccountFilter.AsObject;
|
|
static serializeBinaryToWriter(message: PaymentAccountFilter, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PaymentAccountFilter;
|
|
static deserializeBinaryFromReader(message: PaymentAccountFilter, reader: jspb.BinaryReader): PaymentAccountFilter;
|
|
}
|
|
|
|
export namespace PaymentAccountFilter {
|
|
export type AsObject = {
|
|
paymentMethodId: string,
|
|
getMethodName: string,
|
|
value: string,
|
|
}
|
|
}
|
|
|
|
export class Alert extends jspb.Message {
|
|
getMessage(): string;
|
|
setMessage(value: string): Alert;
|
|
|
|
getVersion(): string;
|
|
setVersion(value: string): Alert;
|
|
|
|
getIsUpdateInfo(): boolean;
|
|
setIsUpdateInfo(value: boolean): Alert;
|
|
|
|
getSignatureAsBase64(): string;
|
|
setSignatureAsBase64(value: string): Alert;
|
|
|
|
getOwnerPubKeyBytes(): Uint8Array | string;
|
|
getOwnerPubKeyBytes_asU8(): Uint8Array;
|
|
getOwnerPubKeyBytes_asB64(): string;
|
|
setOwnerPubKeyBytes(value: Uint8Array | string): Alert;
|
|
|
|
getExtraDataMap(): jspb.Map<string, string>;
|
|
clearExtraDataMap(): Alert;
|
|
|
|
getIsPreReleaseInfo(): boolean;
|
|
setIsPreReleaseInfo(value: boolean): Alert;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): Alert.AsObject;
|
|
static toObject(includeInstance: boolean, msg: Alert): Alert.AsObject;
|
|
static serializeBinaryToWriter(message: Alert, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): Alert;
|
|
static deserializeBinaryFromReader(message: Alert, reader: jspb.BinaryReader): Alert;
|
|
}
|
|
|
|
export namespace Alert {
|
|
export type AsObject = {
|
|
message: string,
|
|
version: string,
|
|
isUpdateInfo: boolean,
|
|
signatureAsBase64: string,
|
|
ownerPubKeyBytes: Uint8Array | string,
|
|
extraDataMap: Array<[string, string]>,
|
|
isPreReleaseInfo: boolean,
|
|
}
|
|
}
|
|
|
|
export class Arbitrator extends jspb.Message {
|
|
getNodeAddress(): NodeAddress | undefined;
|
|
setNodeAddress(value?: NodeAddress): Arbitrator;
|
|
hasNodeAddress(): boolean;
|
|
clearNodeAddress(): Arbitrator;
|
|
|
|
getLanguageCodesList(): Array<string>;
|
|
setLanguageCodesList(value: Array<string>): Arbitrator;
|
|
clearLanguageCodesList(): Arbitrator;
|
|
addLanguageCodes(value: string, index?: number): Arbitrator;
|
|
|
|
getRegistrationDate(): number;
|
|
setRegistrationDate(value: number): Arbitrator;
|
|
|
|
getRegistrationSignature(): string;
|
|
setRegistrationSignature(value: string): Arbitrator;
|
|
|
|
getRegistrationPubKey(): Uint8Array | string;
|
|
getRegistrationPubKey_asU8(): Uint8Array;
|
|
getRegistrationPubKey_asB64(): string;
|
|
setRegistrationPubKey(value: Uint8Array | string): Arbitrator;
|
|
|
|
getPubKeyRing(): PubKeyRing | undefined;
|
|
setPubKeyRing(value?: PubKeyRing): Arbitrator;
|
|
hasPubKeyRing(): boolean;
|
|
clearPubKeyRing(): Arbitrator;
|
|
|
|
getXmrAddress(): string;
|
|
setXmrAddress(value: string): Arbitrator;
|
|
|
|
getEmailAddress(): string;
|
|
setEmailAddress(value: string): Arbitrator;
|
|
|
|
getInfo(): string;
|
|
setInfo(value: string): Arbitrator;
|
|
|
|
getExtraDataMap(): jspb.Map<string, string>;
|
|
clearExtraDataMap(): Arbitrator;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): Arbitrator.AsObject;
|
|
static toObject(includeInstance: boolean, msg: Arbitrator): Arbitrator.AsObject;
|
|
static serializeBinaryToWriter(message: Arbitrator, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): Arbitrator;
|
|
static deserializeBinaryFromReader(message: Arbitrator, reader: jspb.BinaryReader): Arbitrator;
|
|
}
|
|
|
|
export namespace Arbitrator {
|
|
export type AsObject = {
|
|
nodeAddress?: NodeAddress.AsObject,
|
|
languageCodesList: Array<string>,
|
|
registrationDate: number,
|
|
registrationSignature: string,
|
|
registrationPubKey: Uint8Array | string,
|
|
pubKeyRing?: PubKeyRing.AsObject,
|
|
xmrAddress: string,
|
|
emailAddress: string,
|
|
info: string,
|
|
extraDataMap: Array<[string, string]>,
|
|
}
|
|
}
|
|
|
|
export class Mediator extends jspb.Message {
|
|
getNodeAddress(): NodeAddress | undefined;
|
|
setNodeAddress(value?: NodeAddress): Mediator;
|
|
hasNodeAddress(): boolean;
|
|
clearNodeAddress(): Mediator;
|
|
|
|
getLanguageCodesList(): Array<string>;
|
|
setLanguageCodesList(value: Array<string>): Mediator;
|
|
clearLanguageCodesList(): Mediator;
|
|
addLanguageCodes(value: string, index?: number): Mediator;
|
|
|
|
getRegistrationDate(): number;
|
|
setRegistrationDate(value: number): Mediator;
|
|
|
|
getRegistrationSignature(): string;
|
|
setRegistrationSignature(value: string): Mediator;
|
|
|
|
getRegistrationPubKey(): Uint8Array | string;
|
|
getRegistrationPubKey_asU8(): Uint8Array;
|
|
getRegistrationPubKey_asB64(): string;
|
|
setRegistrationPubKey(value: Uint8Array | string): Mediator;
|
|
|
|
getPubKeyRing(): PubKeyRing | undefined;
|
|
setPubKeyRing(value?: PubKeyRing): Mediator;
|
|
hasPubKeyRing(): boolean;
|
|
clearPubKeyRing(): Mediator;
|
|
|
|
getEmailAddress(): string;
|
|
setEmailAddress(value: string): Mediator;
|
|
|
|
getInfo(): string;
|
|
setInfo(value: string): Mediator;
|
|
|
|
getExtraDataMap(): jspb.Map<string, string>;
|
|
clearExtraDataMap(): Mediator;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): Mediator.AsObject;
|
|
static toObject(includeInstance: boolean, msg: Mediator): Mediator.AsObject;
|
|
static serializeBinaryToWriter(message: Mediator, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): Mediator;
|
|
static deserializeBinaryFromReader(message: Mediator, reader: jspb.BinaryReader): Mediator;
|
|
}
|
|
|
|
export namespace Mediator {
|
|
export type AsObject = {
|
|
nodeAddress?: NodeAddress.AsObject,
|
|
languageCodesList: Array<string>,
|
|
registrationDate: number,
|
|
registrationSignature: string,
|
|
registrationPubKey: Uint8Array | string,
|
|
pubKeyRing?: PubKeyRing.AsObject,
|
|
emailAddress: string,
|
|
info: string,
|
|
extraDataMap: Array<[string, string]>,
|
|
}
|
|
}
|
|
|
|
export class RefundAgent extends jspb.Message {
|
|
getNodeAddress(): NodeAddress | undefined;
|
|
setNodeAddress(value?: NodeAddress): RefundAgent;
|
|
hasNodeAddress(): boolean;
|
|
clearNodeAddress(): RefundAgent;
|
|
|
|
getLanguageCodesList(): Array<string>;
|
|
setLanguageCodesList(value: Array<string>): RefundAgent;
|
|
clearLanguageCodesList(): RefundAgent;
|
|
addLanguageCodes(value: string, index?: number): RefundAgent;
|
|
|
|
getRegistrationDate(): number;
|
|
setRegistrationDate(value: number): RefundAgent;
|
|
|
|
getRegistrationSignature(): string;
|
|
setRegistrationSignature(value: string): RefundAgent;
|
|
|
|
getRegistrationPubKey(): Uint8Array | string;
|
|
getRegistrationPubKey_asU8(): Uint8Array;
|
|
getRegistrationPubKey_asB64(): string;
|
|
setRegistrationPubKey(value: Uint8Array | string): RefundAgent;
|
|
|
|
getPubKeyRing(): PubKeyRing | undefined;
|
|
setPubKeyRing(value?: PubKeyRing): RefundAgent;
|
|
hasPubKeyRing(): boolean;
|
|
clearPubKeyRing(): RefundAgent;
|
|
|
|
getEmailAddress(): string;
|
|
setEmailAddress(value: string): RefundAgent;
|
|
|
|
getInfo(): string;
|
|
setInfo(value: string): RefundAgent;
|
|
|
|
getExtraDataMap(): jspb.Map<string, string>;
|
|
clearExtraDataMap(): RefundAgent;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): RefundAgent.AsObject;
|
|
static toObject(includeInstance: boolean, msg: RefundAgent): RefundAgent.AsObject;
|
|
static serializeBinaryToWriter(message: RefundAgent, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): RefundAgent;
|
|
static deserializeBinaryFromReader(message: RefundAgent, reader: jspb.BinaryReader): RefundAgent;
|
|
}
|
|
|
|
export namespace RefundAgent {
|
|
export type AsObject = {
|
|
nodeAddress?: NodeAddress.AsObject,
|
|
languageCodesList: Array<string>,
|
|
registrationDate: number,
|
|
registrationSignature: string,
|
|
registrationPubKey: Uint8Array | string,
|
|
pubKeyRing?: PubKeyRing.AsObject,
|
|
emailAddress: string,
|
|
info: string,
|
|
extraDataMap: Array<[string, string]>,
|
|
}
|
|
}
|
|
|
|
export class Filter extends jspb.Message {
|
|
getNodeAddressesBannedFromTradingList(): Array<string>;
|
|
setNodeAddressesBannedFromTradingList(value: Array<string>): Filter;
|
|
clearNodeAddressesBannedFromTradingList(): Filter;
|
|
addNodeAddressesBannedFromTrading(value: string, index?: number): Filter;
|
|
|
|
getBannedOfferIdsList(): Array<string>;
|
|
setBannedOfferIdsList(value: Array<string>): Filter;
|
|
clearBannedOfferIdsList(): Filter;
|
|
addBannedOfferIds(value: string, index?: number): Filter;
|
|
|
|
getBannedPaymentAccountsList(): Array<PaymentAccountFilter>;
|
|
setBannedPaymentAccountsList(value: Array<PaymentAccountFilter>): Filter;
|
|
clearBannedPaymentAccountsList(): Filter;
|
|
addBannedPaymentAccounts(value?: PaymentAccountFilter, index?: number): PaymentAccountFilter;
|
|
|
|
getSignatureAsBase64(): string;
|
|
setSignatureAsBase64(value: string): Filter;
|
|
|
|
getOwnerPubKeyBytes(): Uint8Array | string;
|
|
getOwnerPubKeyBytes_asU8(): Uint8Array;
|
|
getOwnerPubKeyBytes_asB64(): string;
|
|
setOwnerPubKeyBytes(value: Uint8Array | string): Filter;
|
|
|
|
getExtraDataMap(): jspb.Map<string, string>;
|
|
clearExtraDataMap(): Filter;
|
|
|
|
getBannedCurrenciesList(): Array<string>;
|
|
setBannedCurrenciesList(value: Array<string>): Filter;
|
|
clearBannedCurrenciesList(): Filter;
|
|
addBannedCurrencies(value: string, index?: number): Filter;
|
|
|
|
getBannedPaymentMethodsList(): Array<string>;
|
|
setBannedPaymentMethodsList(value: Array<string>): Filter;
|
|
clearBannedPaymentMethodsList(): Filter;
|
|
addBannedPaymentMethods(value: string, index?: number): Filter;
|
|
|
|
getArbitratorsList(): Array<string>;
|
|
setArbitratorsList(value: Array<string>): Filter;
|
|
clearArbitratorsList(): Filter;
|
|
addArbitrators(value: string, index?: number): Filter;
|
|
|
|
getSeedNodesList(): Array<string>;
|
|
setSeedNodesList(value: Array<string>): Filter;
|
|
clearSeedNodesList(): Filter;
|
|
addSeedNodes(value: string, index?: number): Filter;
|
|
|
|
getPriceRelayNodesList(): Array<string>;
|
|
setPriceRelayNodesList(value: Array<string>): Filter;
|
|
clearPriceRelayNodesList(): Filter;
|
|
addPriceRelayNodes(value: string, index?: number): Filter;
|
|
|
|
getPreventPublicBtcNetwork(): boolean;
|
|
setPreventPublicBtcNetwork(value: boolean): Filter;
|
|
|
|
getBtcNodesList(): Array<string>;
|
|
setBtcNodesList(value: Array<string>): Filter;
|
|
clearBtcNodesList(): Filter;
|
|
addBtcNodes(value: string, index?: number): Filter;
|
|
|
|
getDisableTradeBelowVersion(): string;
|
|
setDisableTradeBelowVersion(value: string): Filter;
|
|
|
|
getMediatorsList(): Array<string>;
|
|
setMediatorsList(value: Array<string>): Filter;
|
|
clearMediatorsList(): Filter;
|
|
addMediators(value: string, index?: number): Filter;
|
|
|
|
getRefundagentsList(): Array<string>;
|
|
setRefundagentsList(value: Array<string>): Filter;
|
|
clearRefundagentsList(): Filter;
|
|
addRefundagents(value: string, index?: number): Filter;
|
|
|
|
getBannedsignerpubkeysList(): Array<string>;
|
|
setBannedsignerpubkeysList(value: Array<string>): Filter;
|
|
clearBannedsignerpubkeysList(): Filter;
|
|
addBannedsignerpubkeys(value: string, index?: number): Filter;
|
|
|
|
getBtcFeeReceiverAddressesList(): Array<string>;
|
|
setBtcFeeReceiverAddressesList(value: Array<string>): Filter;
|
|
clearBtcFeeReceiverAddressesList(): Filter;
|
|
addBtcFeeReceiverAddresses(value: string, index?: number): Filter;
|
|
|
|
getCreationDate(): number;
|
|
setCreationDate(value: number): Filter;
|
|
|
|
getSignerPubKeyAsHex(): string;
|
|
setSignerPubKeyAsHex(value: string): Filter;
|
|
|
|
getBannedprivilegeddevpubkeysList(): Array<string>;
|
|
setBannedprivilegeddevpubkeysList(value: Array<string>): Filter;
|
|
clearBannedprivilegeddevpubkeysList(): Filter;
|
|
addBannedprivilegeddevpubkeys(value: string, index?: number): Filter;
|
|
|
|
getDisableAutoConf(): boolean;
|
|
setDisableAutoConf(value: boolean): Filter;
|
|
|
|
getBannedAutoConfExplorersList(): Array<string>;
|
|
setBannedAutoConfExplorersList(value: Array<string>): Filter;
|
|
clearBannedAutoConfExplorersList(): Filter;
|
|
addBannedAutoConfExplorers(value: string, index?: number): Filter;
|
|
|
|
getNodeAddressesBannedFromNetworkList(): Array<string>;
|
|
setNodeAddressesBannedFromNetworkList(value: Array<string>): Filter;
|
|
clearNodeAddressesBannedFromNetworkList(): Filter;
|
|
addNodeAddressesBannedFromNetwork(value: string, index?: number): Filter;
|
|
|
|
getDisableApi(): boolean;
|
|
setDisableApi(value: boolean): Filter;
|
|
|
|
getDisableMempoolValidation(): boolean;
|
|
setDisableMempoolValidation(value: boolean): Filter;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): Filter.AsObject;
|
|
static toObject(includeInstance: boolean, msg: Filter): Filter.AsObject;
|
|
static serializeBinaryToWriter(message: Filter, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): Filter;
|
|
static deserializeBinaryFromReader(message: Filter, reader: jspb.BinaryReader): Filter;
|
|
}
|
|
|
|
export namespace Filter {
|
|
export type AsObject = {
|
|
nodeAddressesBannedFromTradingList: Array<string>,
|
|
bannedOfferIdsList: Array<string>,
|
|
bannedPaymentAccountsList: Array<PaymentAccountFilter.AsObject>,
|
|
signatureAsBase64: string,
|
|
ownerPubKeyBytes: Uint8Array | string,
|
|
extraDataMap: Array<[string, string]>,
|
|
bannedCurrenciesList: Array<string>,
|
|
bannedPaymentMethodsList: Array<string>,
|
|
arbitratorsList: Array<string>,
|
|
seedNodesList: Array<string>,
|
|
priceRelayNodesList: Array<string>,
|
|
preventPublicBtcNetwork: boolean,
|
|
btcNodesList: Array<string>,
|
|
disableTradeBelowVersion: string,
|
|
mediatorsList: Array<string>,
|
|
refundagentsList: Array<string>,
|
|
bannedsignerpubkeysList: Array<string>,
|
|
btcFeeReceiverAddressesList: Array<string>,
|
|
creationDate: number,
|
|
signerPubKeyAsHex: string,
|
|
bannedprivilegeddevpubkeysList: Array<string>,
|
|
disableAutoConf: boolean,
|
|
bannedAutoConfExplorersList: Array<string>,
|
|
nodeAddressesBannedFromNetworkList: Array<string>,
|
|
disableApi: boolean,
|
|
disableMempoolValidation: boolean,
|
|
}
|
|
}
|
|
|
|
export class TradeStatistics2 extends jspb.Message {
|
|
getBaseCurrency(): string;
|
|
setBaseCurrency(value: string): TradeStatistics2;
|
|
|
|
getCounterCurrency(): string;
|
|
setCounterCurrency(value: string): TradeStatistics2;
|
|
|
|
getDirection(): OfferDirection;
|
|
setDirection(value: OfferDirection): TradeStatistics2;
|
|
|
|
getTradePrice(): number;
|
|
setTradePrice(value: number): TradeStatistics2;
|
|
|
|
getTradeAmount(): number;
|
|
setTradeAmount(value: number): TradeStatistics2;
|
|
|
|
getTradeDate(): number;
|
|
setTradeDate(value: number): TradeStatistics2;
|
|
|
|
getPaymentMethodId(): string;
|
|
setPaymentMethodId(value: string): TradeStatistics2;
|
|
|
|
getOfferDate(): number;
|
|
setOfferDate(value: number): TradeStatistics2;
|
|
|
|
getOfferUseMarketBasedPrice(): boolean;
|
|
setOfferUseMarketBasedPrice(value: boolean): TradeStatistics2;
|
|
|
|
getOfferMarketPriceMargin(): number;
|
|
setOfferMarketPriceMargin(value: number): TradeStatistics2;
|
|
|
|
getOfferAmount(): number;
|
|
setOfferAmount(value: number): TradeStatistics2;
|
|
|
|
getOfferMinAmount(): number;
|
|
setOfferMinAmount(value: number): TradeStatistics2;
|
|
|
|
getOfferId(): string;
|
|
setOfferId(value: string): TradeStatistics2;
|
|
|
|
getDepositTxId(): string;
|
|
setDepositTxId(value: string): TradeStatistics2;
|
|
|
|
getHash(): Uint8Array | string;
|
|
getHash_asU8(): Uint8Array;
|
|
getHash_asB64(): string;
|
|
setHash(value: Uint8Array | string): TradeStatistics2;
|
|
|
|
getExtraDataMap(): jspb.Map<string, string>;
|
|
clearExtraDataMap(): TradeStatistics2;
|
|
|
|
getMakerDepositTxId(): string;
|
|
setMakerDepositTxId(value: string): TradeStatistics2;
|
|
|
|
getTakerDepositTxId(): string;
|
|
setTakerDepositTxId(value: string): TradeStatistics2;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): TradeStatistics2.AsObject;
|
|
static toObject(includeInstance: boolean, msg: TradeStatistics2): TradeStatistics2.AsObject;
|
|
static serializeBinaryToWriter(message: TradeStatistics2, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): TradeStatistics2;
|
|
static deserializeBinaryFromReader(message: TradeStatistics2, reader: jspb.BinaryReader): TradeStatistics2;
|
|
}
|
|
|
|
export namespace TradeStatistics2 {
|
|
export type AsObject = {
|
|
baseCurrency: string,
|
|
counterCurrency: string,
|
|
direction: OfferDirection,
|
|
tradePrice: number,
|
|
tradeAmount: number,
|
|
tradeDate: number,
|
|
paymentMethodId: string,
|
|
offerDate: number,
|
|
offerUseMarketBasedPrice: boolean,
|
|
offerMarketPriceMargin: number,
|
|
offerAmount: number,
|
|
offerMinAmount: number,
|
|
offerId: string,
|
|
depositTxId: string,
|
|
hash: Uint8Array | string,
|
|
extraDataMap: Array<[string, string]>,
|
|
makerDepositTxId: string,
|
|
takerDepositTxId: string,
|
|
}
|
|
}
|
|
|
|
export class TradeStatistics3 extends jspb.Message {
|
|
getCurrency(): string;
|
|
setCurrency(value: string): TradeStatistics3;
|
|
|
|
getPrice(): number;
|
|
setPrice(value: number): TradeStatistics3;
|
|
|
|
getAmount(): number;
|
|
setAmount(value: number): TradeStatistics3;
|
|
|
|
getPaymentMethod(): string;
|
|
setPaymentMethod(value: string): TradeStatistics3;
|
|
|
|
getDate(): number;
|
|
setDate(value: number): TradeStatistics3;
|
|
|
|
getHash(): Uint8Array | string;
|
|
getHash_asU8(): Uint8Array;
|
|
getHash_asB64(): string;
|
|
setHash(value: Uint8Array | string): TradeStatistics3;
|
|
|
|
getExtraDataMap(): jspb.Map<string, string>;
|
|
clearExtraDataMap(): TradeStatistics3;
|
|
|
|
getArbitrator(): string;
|
|
setArbitrator(value: string): TradeStatistics3;
|
|
|
|
getMakerDepositTxId(): string;
|
|
setMakerDepositTxId(value: string): TradeStatistics3;
|
|
|
|
getTakerDepositTxId(): string;
|
|
setTakerDepositTxId(value: string): TradeStatistics3;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): TradeStatistics3.AsObject;
|
|
static toObject(includeInstance: boolean, msg: TradeStatistics3): TradeStatistics3.AsObject;
|
|
static serializeBinaryToWriter(message: TradeStatistics3, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): TradeStatistics3;
|
|
static deserializeBinaryFromReader(message: TradeStatistics3, reader: jspb.BinaryReader): TradeStatistics3;
|
|
}
|
|
|
|
export namespace TradeStatistics3 {
|
|
export type AsObject = {
|
|
currency: string,
|
|
price: number,
|
|
amount: number,
|
|
paymentMethod: string,
|
|
date: number,
|
|
hash: Uint8Array | string,
|
|
extraDataMap: Array<[string, string]>,
|
|
arbitrator: string,
|
|
makerDepositTxId: string,
|
|
takerDepositTxId: string,
|
|
}
|
|
}
|
|
|
|
export class MailboxStoragePayload extends jspb.Message {
|
|
getPrefixedSealedAndSignedMessage(): PrefixedSealedAndSignedMessage | undefined;
|
|
setPrefixedSealedAndSignedMessage(value?: PrefixedSealedAndSignedMessage): MailboxStoragePayload;
|
|
hasPrefixedSealedAndSignedMessage(): boolean;
|
|
clearPrefixedSealedAndSignedMessage(): MailboxStoragePayload;
|
|
|
|
getSenderPubKeyForAddOperationBytes(): Uint8Array | string;
|
|
getSenderPubKeyForAddOperationBytes_asU8(): Uint8Array;
|
|
getSenderPubKeyForAddOperationBytes_asB64(): string;
|
|
setSenderPubKeyForAddOperationBytes(value: Uint8Array | string): MailboxStoragePayload;
|
|
|
|
getOwnerPubKeyBytes(): Uint8Array | string;
|
|
getOwnerPubKeyBytes_asU8(): Uint8Array;
|
|
getOwnerPubKeyBytes_asB64(): string;
|
|
setOwnerPubKeyBytes(value: Uint8Array | string): MailboxStoragePayload;
|
|
|
|
getExtraDataMap(): jspb.Map<string, string>;
|
|
clearExtraDataMap(): MailboxStoragePayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): MailboxStoragePayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: MailboxStoragePayload): MailboxStoragePayload.AsObject;
|
|
static serializeBinaryToWriter(message: MailboxStoragePayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): MailboxStoragePayload;
|
|
static deserializeBinaryFromReader(message: MailboxStoragePayload, reader: jspb.BinaryReader): MailboxStoragePayload;
|
|
}
|
|
|
|
export namespace MailboxStoragePayload {
|
|
export type AsObject = {
|
|
prefixedSealedAndSignedMessage?: PrefixedSealedAndSignedMessage.AsObject,
|
|
senderPubKeyForAddOperationBytes: Uint8Array | string,
|
|
ownerPubKeyBytes: Uint8Array | string,
|
|
extraDataMap: Array<[string, string]>,
|
|
}
|
|
}
|
|
|
|
export class OfferPayload extends jspb.Message {
|
|
getId(): string;
|
|
setId(value: string): OfferPayload;
|
|
|
|
getDate(): number;
|
|
setDate(value: number): OfferPayload;
|
|
|
|
getOwnerNodeAddress(): NodeAddress | undefined;
|
|
setOwnerNodeAddress(value?: NodeAddress): OfferPayload;
|
|
hasOwnerNodeAddress(): boolean;
|
|
clearOwnerNodeAddress(): OfferPayload;
|
|
|
|
getPubKeyRing(): PubKeyRing | undefined;
|
|
setPubKeyRing(value?: PubKeyRing): OfferPayload;
|
|
hasPubKeyRing(): boolean;
|
|
clearPubKeyRing(): OfferPayload;
|
|
|
|
getDirection(): OfferDirection;
|
|
setDirection(value: OfferDirection): OfferPayload;
|
|
|
|
getPrice(): number;
|
|
setPrice(value: number): OfferPayload;
|
|
|
|
getMarketPriceMarginPct(): number;
|
|
setMarketPriceMarginPct(value: number): OfferPayload;
|
|
|
|
getUseMarketBasedPrice(): boolean;
|
|
setUseMarketBasedPrice(value: boolean): OfferPayload;
|
|
|
|
getAmount(): number;
|
|
setAmount(value: number): OfferPayload;
|
|
|
|
getMinAmount(): number;
|
|
setMinAmount(value: number): OfferPayload;
|
|
|
|
getBaseCurrencyCode(): string;
|
|
setBaseCurrencyCode(value: string): OfferPayload;
|
|
|
|
getCounterCurrencyCode(): string;
|
|
setCounterCurrencyCode(value: string): OfferPayload;
|
|
|
|
getPaymentMethodId(): string;
|
|
setPaymentMethodId(value: string): OfferPayload;
|
|
|
|
getMakerPaymentAccountId(): string;
|
|
setMakerPaymentAccountId(value: string): OfferPayload;
|
|
|
|
getOfferFeePaymentTxId(): string;
|
|
setOfferFeePaymentTxId(value: string): OfferPayload;
|
|
|
|
getCountryCode(): string;
|
|
setCountryCode(value: string): OfferPayload;
|
|
|
|
getAcceptedCountryCodesList(): Array<string>;
|
|
setAcceptedCountryCodesList(value: Array<string>): OfferPayload;
|
|
clearAcceptedCountryCodesList(): OfferPayload;
|
|
addAcceptedCountryCodes(value: string, index?: number): OfferPayload;
|
|
|
|
getBankId(): string;
|
|
setBankId(value: string): OfferPayload;
|
|
|
|
getAcceptedBankIdsList(): Array<string>;
|
|
setAcceptedBankIdsList(value: Array<string>): OfferPayload;
|
|
clearAcceptedBankIdsList(): OfferPayload;
|
|
addAcceptedBankIds(value: string, index?: number): OfferPayload;
|
|
|
|
getVersionNr(): string;
|
|
setVersionNr(value: string): OfferPayload;
|
|
|
|
getBlockHeightAtOfferCreation(): number;
|
|
setBlockHeightAtOfferCreation(value: number): OfferPayload;
|
|
|
|
getMakerFee(): number;
|
|
setMakerFee(value: number): OfferPayload;
|
|
|
|
getBuyerSecurityDeposit(): number;
|
|
setBuyerSecurityDeposit(value: number): OfferPayload;
|
|
|
|
getSellerSecurityDeposit(): number;
|
|
setSellerSecurityDeposit(value: number): OfferPayload;
|
|
|
|
getMaxTradeLimit(): number;
|
|
setMaxTradeLimit(value: number): OfferPayload;
|
|
|
|
getMaxTradePeriod(): number;
|
|
setMaxTradePeriod(value: number): OfferPayload;
|
|
|
|
getUseAutoClose(): boolean;
|
|
setUseAutoClose(value: boolean): OfferPayload;
|
|
|
|
getUseReOpenAfterAutoClose(): boolean;
|
|
setUseReOpenAfterAutoClose(value: boolean): OfferPayload;
|
|
|
|
getLowerClosePrice(): number;
|
|
setLowerClosePrice(value: number): OfferPayload;
|
|
|
|
getUpperClosePrice(): number;
|
|
setUpperClosePrice(value: number): OfferPayload;
|
|
|
|
getIsPrivateOffer(): boolean;
|
|
setIsPrivateOffer(value: boolean): OfferPayload;
|
|
|
|
getHashOfChallenge(): string;
|
|
setHashOfChallenge(value: string): OfferPayload;
|
|
|
|
getExtraDataMap(): jspb.Map<string, string>;
|
|
clearExtraDataMap(): OfferPayload;
|
|
|
|
getProtocolVersion(): number;
|
|
setProtocolVersion(value: number): OfferPayload;
|
|
|
|
getArbitratorSigner(): NodeAddress | undefined;
|
|
setArbitratorSigner(value?: NodeAddress): OfferPayload;
|
|
hasArbitratorSigner(): boolean;
|
|
clearArbitratorSigner(): OfferPayload;
|
|
|
|
getArbitratorSignature(): string;
|
|
setArbitratorSignature(value: string): OfferPayload;
|
|
|
|
getReserveTxKeyImagesList(): Array<string>;
|
|
setReserveTxKeyImagesList(value: Array<string>): OfferPayload;
|
|
clearReserveTxKeyImagesList(): OfferPayload;
|
|
addReserveTxKeyImages(value: string, index?: number): OfferPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): OfferPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: OfferPayload): OfferPayload.AsObject;
|
|
static serializeBinaryToWriter(message: OfferPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): OfferPayload;
|
|
static deserializeBinaryFromReader(message: OfferPayload, reader: jspb.BinaryReader): OfferPayload;
|
|
}
|
|
|
|
export namespace OfferPayload {
|
|
export type AsObject = {
|
|
id: string,
|
|
date: number,
|
|
ownerNodeAddress?: NodeAddress.AsObject,
|
|
pubKeyRing?: PubKeyRing.AsObject,
|
|
direction: OfferDirection,
|
|
price: number,
|
|
marketPriceMarginPct: number,
|
|
useMarketBasedPrice: boolean,
|
|
amount: number,
|
|
minAmount: number,
|
|
baseCurrencyCode: string,
|
|
counterCurrencyCode: string,
|
|
paymentMethodId: string,
|
|
makerPaymentAccountId: string,
|
|
offerFeePaymentTxId: string,
|
|
countryCode: string,
|
|
acceptedCountryCodesList: Array<string>,
|
|
bankId: string,
|
|
acceptedBankIdsList: Array<string>,
|
|
versionNr: string,
|
|
blockHeightAtOfferCreation: number,
|
|
makerFee: number,
|
|
buyerSecurityDeposit: number,
|
|
sellerSecurityDeposit: number,
|
|
maxTradeLimit: number,
|
|
maxTradePeriod: number,
|
|
useAutoClose: boolean,
|
|
useReOpenAfterAutoClose: boolean,
|
|
lowerClosePrice: number,
|
|
upperClosePrice: number,
|
|
isPrivateOffer: boolean,
|
|
hashOfChallenge: string,
|
|
extraDataMap: Array<[string, string]>,
|
|
protocolVersion: number,
|
|
arbitratorSigner?: NodeAddress.AsObject,
|
|
arbitratorSignature: string,
|
|
reserveTxKeyImagesList: Array<string>,
|
|
}
|
|
}
|
|
|
|
export class AccountAgeWitness extends jspb.Message {
|
|
getHash(): Uint8Array | string;
|
|
getHash_asU8(): Uint8Array;
|
|
getHash_asB64(): string;
|
|
setHash(value: Uint8Array | string): AccountAgeWitness;
|
|
|
|
getDate(): number;
|
|
setDate(value: number): AccountAgeWitness;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): AccountAgeWitness.AsObject;
|
|
static toObject(includeInstance: boolean, msg: AccountAgeWitness): AccountAgeWitness.AsObject;
|
|
static serializeBinaryToWriter(message: AccountAgeWitness, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): AccountAgeWitness;
|
|
static deserializeBinaryFromReader(message: AccountAgeWitness, reader: jspb.BinaryReader): AccountAgeWitness;
|
|
}
|
|
|
|
export namespace AccountAgeWitness {
|
|
export type AsObject = {
|
|
hash: Uint8Array | string,
|
|
date: number,
|
|
}
|
|
}
|
|
|
|
export class SignedWitness extends jspb.Message {
|
|
getVerificationMethod(): SignedWitness.VerificationMethod;
|
|
setVerificationMethod(value: SignedWitness.VerificationMethod): SignedWitness;
|
|
|
|
getAccountAgeWitnessHash(): Uint8Array | string;
|
|
getAccountAgeWitnessHash_asU8(): Uint8Array;
|
|
getAccountAgeWitnessHash_asB64(): string;
|
|
setAccountAgeWitnessHash(value: Uint8Array | string): SignedWitness;
|
|
|
|
getSignature(): Uint8Array | string;
|
|
getSignature_asU8(): Uint8Array;
|
|
getSignature_asB64(): string;
|
|
setSignature(value: Uint8Array | string): SignedWitness;
|
|
|
|
getSignerPubKey(): Uint8Array | string;
|
|
getSignerPubKey_asU8(): Uint8Array;
|
|
getSignerPubKey_asB64(): string;
|
|
setSignerPubKey(value: Uint8Array | string): SignedWitness;
|
|
|
|
getWitnessOwnerPubKey(): Uint8Array | string;
|
|
getWitnessOwnerPubKey_asU8(): Uint8Array;
|
|
getWitnessOwnerPubKey_asB64(): string;
|
|
setWitnessOwnerPubKey(value: Uint8Array | string): SignedWitness;
|
|
|
|
getDate(): number;
|
|
setDate(value: number): SignedWitness;
|
|
|
|
getTradeAmount(): number;
|
|
setTradeAmount(value: number): SignedWitness;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): SignedWitness.AsObject;
|
|
static toObject(includeInstance: boolean, msg: SignedWitness): SignedWitness.AsObject;
|
|
static serializeBinaryToWriter(message: SignedWitness, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): SignedWitness;
|
|
static deserializeBinaryFromReader(message: SignedWitness, reader: jspb.BinaryReader): SignedWitness;
|
|
}
|
|
|
|
export namespace SignedWitness {
|
|
export type AsObject = {
|
|
verificationMethod: SignedWitness.VerificationMethod,
|
|
accountAgeWitnessHash: Uint8Array | string,
|
|
signature: Uint8Array | string,
|
|
signerPubKey: Uint8Array | string,
|
|
witnessOwnerPubKey: Uint8Array | string,
|
|
date: number,
|
|
tradeAmount: number,
|
|
}
|
|
|
|
export enum VerificationMethod {
|
|
PB_ERROR = 0,
|
|
ARBITRATOR = 1,
|
|
TRADE = 2,
|
|
}
|
|
}
|
|
|
|
export class Dispute extends jspb.Message {
|
|
getTradeId(): string;
|
|
setTradeId(value: string): Dispute;
|
|
|
|
getId(): string;
|
|
setId(value: string): Dispute;
|
|
|
|
getTraderId(): number;
|
|
setTraderId(value: number): Dispute;
|
|
|
|
getIsOpener(): boolean;
|
|
setIsOpener(value: boolean): Dispute;
|
|
|
|
getDisputeOpenerIsBuyer(): boolean;
|
|
setDisputeOpenerIsBuyer(value: boolean): Dispute;
|
|
|
|
getDisputeOpenerIsMaker(): boolean;
|
|
setDisputeOpenerIsMaker(value: boolean): Dispute;
|
|
|
|
getOpeningDate(): number;
|
|
setOpeningDate(value: number): Dispute;
|
|
|
|
getTraderPubKeyRing(): PubKeyRing | undefined;
|
|
setTraderPubKeyRing(value?: PubKeyRing): Dispute;
|
|
hasTraderPubKeyRing(): boolean;
|
|
clearTraderPubKeyRing(): Dispute;
|
|
|
|
getTradeDate(): number;
|
|
setTradeDate(value: number): Dispute;
|
|
|
|
getContract(): Contract | undefined;
|
|
setContract(value?: Contract): Dispute;
|
|
hasContract(): boolean;
|
|
clearContract(): Dispute;
|
|
|
|
getContractHash(): Uint8Array | string;
|
|
getContractHash_asU8(): Uint8Array;
|
|
getContractHash_asB64(): string;
|
|
setContractHash(value: Uint8Array | string): Dispute;
|
|
|
|
getDepositTxSerialized(): Uint8Array | string;
|
|
getDepositTxSerialized_asU8(): Uint8Array;
|
|
getDepositTxSerialized_asB64(): string;
|
|
setDepositTxSerialized(value: Uint8Array | string): Dispute;
|
|
|
|
getPayoutTxSerialized(): Uint8Array | string;
|
|
getPayoutTxSerialized_asU8(): Uint8Array;
|
|
getPayoutTxSerialized_asB64(): string;
|
|
setPayoutTxSerialized(value: Uint8Array | string): Dispute;
|
|
|
|
getDepositTxId(): string;
|
|
setDepositTxId(value: string): Dispute;
|
|
|
|
getPayoutTxId(): string;
|
|
setPayoutTxId(value: string): Dispute;
|
|
|
|
getContractAsJson(): string;
|
|
setContractAsJson(value: string): Dispute;
|
|
|
|
getMakerContractSignature(): string;
|
|
setMakerContractSignature(value: string): Dispute;
|
|
|
|
getTakerContractSignature(): string;
|
|
setTakerContractSignature(value: string): Dispute;
|
|
|
|
getMakerPaymentAccountPayload(): PaymentAccountPayload | undefined;
|
|
setMakerPaymentAccountPayload(value?: PaymentAccountPayload): Dispute;
|
|
hasMakerPaymentAccountPayload(): boolean;
|
|
clearMakerPaymentAccountPayload(): Dispute;
|
|
|
|
getTakerPaymentAccountPayload(): PaymentAccountPayload | undefined;
|
|
setTakerPaymentAccountPayload(value?: PaymentAccountPayload): Dispute;
|
|
hasTakerPaymentAccountPayload(): boolean;
|
|
clearTakerPaymentAccountPayload(): Dispute;
|
|
|
|
getAgentPubKeyRing(): PubKeyRing | undefined;
|
|
setAgentPubKeyRing(value?: PubKeyRing): Dispute;
|
|
hasAgentPubKeyRing(): boolean;
|
|
clearAgentPubKeyRing(): Dispute;
|
|
|
|
getIsSupportTicket(): boolean;
|
|
setIsSupportTicket(value: boolean): Dispute;
|
|
|
|
getChatMessageList(): Array<ChatMessage>;
|
|
setChatMessageList(value: Array<ChatMessage>): Dispute;
|
|
clearChatMessageList(): Dispute;
|
|
addChatMessage(value?: ChatMessage, index?: number): ChatMessage;
|
|
|
|
getIsClosed(): boolean;
|
|
setIsClosed(value: boolean): Dispute;
|
|
|
|
getDisputeResult(): DisputeResult | undefined;
|
|
setDisputeResult(value?: DisputeResult): Dispute;
|
|
hasDisputeResult(): boolean;
|
|
clearDisputeResult(): Dispute;
|
|
|
|
getDisputePayoutTxId(): string;
|
|
setDisputePayoutTxId(value: string): Dispute;
|
|
|
|
getSupportType(): SupportType;
|
|
setSupportType(value: SupportType): Dispute;
|
|
|
|
getMediatorsDisputeResult(): string;
|
|
setMediatorsDisputeResult(value: string): Dispute;
|
|
|
|
getDelayedPayoutTxId(): string;
|
|
setDelayedPayoutTxId(value: string): Dispute;
|
|
|
|
getDonationAddressOfDelayedPayoutTx(): string;
|
|
setDonationAddressOfDelayedPayoutTx(value: string): Dispute;
|
|
|
|
getState(): Dispute.State;
|
|
setState(value: Dispute.State): Dispute;
|
|
|
|
getTradePeriodEnd(): number;
|
|
setTradePeriodEnd(value: number): Dispute;
|
|
|
|
getExtraDataMap(): jspb.Map<string, string>;
|
|
clearExtraDataMap(): Dispute;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): Dispute.AsObject;
|
|
static toObject(includeInstance: boolean, msg: Dispute): Dispute.AsObject;
|
|
static serializeBinaryToWriter(message: Dispute, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): Dispute;
|
|
static deserializeBinaryFromReader(message: Dispute, reader: jspb.BinaryReader): Dispute;
|
|
}
|
|
|
|
export namespace Dispute {
|
|
export type AsObject = {
|
|
tradeId: string,
|
|
id: string,
|
|
traderId: number,
|
|
isOpener: boolean,
|
|
disputeOpenerIsBuyer: boolean,
|
|
disputeOpenerIsMaker: boolean,
|
|
openingDate: number,
|
|
traderPubKeyRing?: PubKeyRing.AsObject,
|
|
tradeDate: number,
|
|
contract?: Contract.AsObject,
|
|
contractHash: Uint8Array | string,
|
|
depositTxSerialized: Uint8Array | string,
|
|
payoutTxSerialized: Uint8Array | string,
|
|
depositTxId: string,
|
|
payoutTxId: string,
|
|
contractAsJson: string,
|
|
makerContractSignature: string,
|
|
takerContractSignature: string,
|
|
makerPaymentAccountPayload?: PaymentAccountPayload.AsObject,
|
|
takerPaymentAccountPayload?: PaymentAccountPayload.AsObject,
|
|
agentPubKeyRing?: PubKeyRing.AsObject,
|
|
isSupportTicket: boolean,
|
|
chatMessageList: Array<ChatMessage.AsObject>,
|
|
isClosed: boolean,
|
|
disputeResult?: DisputeResult.AsObject,
|
|
disputePayoutTxId: string,
|
|
supportType: SupportType,
|
|
mediatorsDisputeResult: string,
|
|
delayedPayoutTxId: string,
|
|
donationAddressOfDelayedPayoutTx: string,
|
|
state: Dispute.State,
|
|
tradePeriodEnd: number,
|
|
extraDataMap: Array<[string, string]>,
|
|
}
|
|
|
|
export enum State {
|
|
NEEDS_UPGRADE = 0,
|
|
NEW = 1,
|
|
OPEN = 2,
|
|
REOPENED = 3,
|
|
CLOSED = 4,
|
|
}
|
|
}
|
|
|
|
export class Attachment extends jspb.Message {
|
|
getFileName(): string;
|
|
setFileName(value: string): Attachment;
|
|
|
|
getBytes(): Uint8Array | string;
|
|
getBytes_asU8(): Uint8Array;
|
|
getBytes_asB64(): string;
|
|
setBytes(value: Uint8Array | string): Attachment;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): Attachment.AsObject;
|
|
static toObject(includeInstance: boolean, msg: Attachment): Attachment.AsObject;
|
|
static serializeBinaryToWriter(message: Attachment, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): Attachment;
|
|
static deserializeBinaryFromReader(message: Attachment, reader: jspb.BinaryReader): Attachment;
|
|
}
|
|
|
|
export namespace Attachment {
|
|
export type AsObject = {
|
|
fileName: string,
|
|
bytes: Uint8Array | string,
|
|
}
|
|
}
|
|
|
|
export class DisputeResult extends jspb.Message {
|
|
getTradeId(): string;
|
|
setTradeId(value: string): DisputeResult;
|
|
|
|
getTraderId(): number;
|
|
setTraderId(value: number): DisputeResult;
|
|
|
|
getWinner(): DisputeResult.Winner;
|
|
setWinner(value: DisputeResult.Winner): DisputeResult;
|
|
|
|
getReasonOrdinal(): number;
|
|
setReasonOrdinal(value: number): DisputeResult;
|
|
|
|
getTamperProofEvidence(): boolean;
|
|
setTamperProofEvidence(value: boolean): DisputeResult;
|
|
|
|
getIdVerification(): boolean;
|
|
setIdVerification(value: boolean): DisputeResult;
|
|
|
|
getScreenCast(): boolean;
|
|
setScreenCast(value: boolean): DisputeResult;
|
|
|
|
getSummaryNotes(): string;
|
|
setSummaryNotes(value: string): DisputeResult;
|
|
|
|
getChatMessage(): ChatMessage | undefined;
|
|
setChatMessage(value?: ChatMessage): DisputeResult;
|
|
hasChatMessage(): boolean;
|
|
clearChatMessage(): DisputeResult;
|
|
|
|
getArbitratorSignature(): Uint8Array | string;
|
|
getArbitratorSignature_asU8(): Uint8Array;
|
|
getArbitratorSignature_asB64(): string;
|
|
setArbitratorSignature(value: Uint8Array | string): DisputeResult;
|
|
|
|
getBuyerPayoutAmount(): number;
|
|
setBuyerPayoutAmount(value: number): DisputeResult;
|
|
|
|
getSellerPayoutAmount(): number;
|
|
setSellerPayoutAmount(value: number): DisputeResult;
|
|
|
|
getArbitratorPubKey(): Uint8Array | string;
|
|
getArbitratorPubKey_asU8(): Uint8Array;
|
|
getArbitratorPubKey_asB64(): string;
|
|
setArbitratorPubKey(value: Uint8Array | string): DisputeResult;
|
|
|
|
getCloseDate(): number;
|
|
setCloseDate(value: number): DisputeResult;
|
|
|
|
getIsLoserPublisher(): boolean;
|
|
setIsLoserPublisher(value: boolean): DisputeResult;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): DisputeResult.AsObject;
|
|
static toObject(includeInstance: boolean, msg: DisputeResult): DisputeResult.AsObject;
|
|
static serializeBinaryToWriter(message: DisputeResult, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): DisputeResult;
|
|
static deserializeBinaryFromReader(message: DisputeResult, reader: jspb.BinaryReader): DisputeResult;
|
|
}
|
|
|
|
export namespace DisputeResult {
|
|
export type AsObject = {
|
|
tradeId: string,
|
|
traderId: number,
|
|
winner: DisputeResult.Winner,
|
|
reasonOrdinal: number,
|
|
tamperProofEvidence: boolean,
|
|
idVerification: boolean,
|
|
screenCast: boolean,
|
|
summaryNotes: string,
|
|
chatMessage?: ChatMessage.AsObject,
|
|
arbitratorSignature: Uint8Array | string,
|
|
buyerPayoutAmount: number,
|
|
sellerPayoutAmount: number,
|
|
arbitratorPubKey: Uint8Array | string,
|
|
closeDate: number,
|
|
isLoserPublisher: boolean,
|
|
}
|
|
|
|
export enum Winner {
|
|
PB_ERROR_WINNER = 0,
|
|
BUYER = 1,
|
|
SELLER = 2,
|
|
}
|
|
|
|
export enum Reason {
|
|
PB_ERROR_REASON = 0,
|
|
OTHER = 1,
|
|
BUG = 2,
|
|
USABILITY = 3,
|
|
SCAM = 4,
|
|
PROTOCOL_VIOLATION = 5,
|
|
NO_REPLY = 6,
|
|
BANK_PROBLEMS = 7,
|
|
OPTION_TRADE = 8,
|
|
SELLER_NOT_RESPONDING = 9,
|
|
WRONG_SENDER_ACCOUNT = 10,
|
|
TRADE_ALREADY_SETTLED = 11,
|
|
PEER_WAS_LATE = 12,
|
|
}
|
|
}
|
|
|
|
export class Contract extends jspb.Message {
|
|
getOfferPayload(): OfferPayload | undefined;
|
|
setOfferPayload(value?: OfferPayload): Contract;
|
|
hasOfferPayload(): boolean;
|
|
clearOfferPayload(): Contract;
|
|
|
|
getTradeAmount(): number;
|
|
setTradeAmount(value: number): Contract;
|
|
|
|
getTradePrice(): number;
|
|
setTradePrice(value: number): Contract;
|
|
|
|
getIsBuyerMakerAndSellerTaker(): boolean;
|
|
setIsBuyerMakerAndSellerTaker(value: boolean): Contract;
|
|
|
|
getMakerAccountId(): string;
|
|
setMakerAccountId(value: string): Contract;
|
|
|
|
getTakerAccountId(): string;
|
|
setTakerAccountId(value: string): Contract;
|
|
|
|
getMakerPaymentMethodId(): string;
|
|
setMakerPaymentMethodId(value: string): Contract;
|
|
|
|
getTakerPaymentMethodId(): string;
|
|
setTakerPaymentMethodId(value: string): Contract;
|
|
|
|
getMakerPaymentAccountPayloadHash(): Uint8Array | string;
|
|
getMakerPaymentAccountPayloadHash_asU8(): Uint8Array;
|
|
getMakerPaymentAccountPayloadHash_asB64(): string;
|
|
setMakerPaymentAccountPayloadHash(value: Uint8Array | string): Contract;
|
|
|
|
getTakerPaymentAccountPayloadHash(): Uint8Array | string;
|
|
getTakerPaymentAccountPayloadHash_asU8(): Uint8Array;
|
|
getTakerPaymentAccountPayloadHash_asB64(): string;
|
|
setTakerPaymentAccountPayloadHash(value: Uint8Array | string): Contract;
|
|
|
|
getMakerPubKeyRing(): PubKeyRing | undefined;
|
|
setMakerPubKeyRing(value?: PubKeyRing): Contract;
|
|
hasMakerPubKeyRing(): boolean;
|
|
clearMakerPubKeyRing(): Contract;
|
|
|
|
getTakerPubKeyRing(): PubKeyRing | undefined;
|
|
setTakerPubKeyRing(value?: PubKeyRing): Contract;
|
|
hasTakerPubKeyRing(): boolean;
|
|
clearTakerPubKeyRing(): Contract;
|
|
|
|
getBuyerNodeAddress(): NodeAddress | undefined;
|
|
setBuyerNodeAddress(value?: NodeAddress): Contract;
|
|
hasBuyerNodeAddress(): boolean;
|
|
clearBuyerNodeAddress(): Contract;
|
|
|
|
getSellerNodeAddress(): NodeAddress | undefined;
|
|
setSellerNodeAddress(value?: NodeAddress): Contract;
|
|
hasSellerNodeAddress(): boolean;
|
|
clearSellerNodeAddress(): Contract;
|
|
|
|
getMakerPayoutAddressString(): string;
|
|
setMakerPayoutAddressString(value: string): Contract;
|
|
|
|
getTakerPayoutAddressString(): string;
|
|
setTakerPayoutAddressString(value: string): Contract;
|
|
|
|
getArbitratorNodeAddress(): NodeAddress | undefined;
|
|
setArbitratorNodeAddress(value?: NodeAddress): Contract;
|
|
hasArbitratorNodeAddress(): boolean;
|
|
clearArbitratorNodeAddress(): Contract;
|
|
|
|
getLockTime(): number;
|
|
setLockTime(value: number): Contract;
|
|
|
|
getMakerDepositTxHash(): string;
|
|
setMakerDepositTxHash(value: string): Contract;
|
|
|
|
getTakerDepositTxHash(): string;
|
|
setTakerDepositTxHash(value: string): Contract;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): Contract.AsObject;
|
|
static toObject(includeInstance: boolean, msg: Contract): Contract.AsObject;
|
|
static serializeBinaryToWriter(message: Contract, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): Contract;
|
|
static deserializeBinaryFromReader(message: Contract, reader: jspb.BinaryReader): Contract;
|
|
}
|
|
|
|
export namespace Contract {
|
|
export type AsObject = {
|
|
offerPayload?: OfferPayload.AsObject,
|
|
tradeAmount: number,
|
|
tradePrice: number,
|
|
isBuyerMakerAndSellerTaker: boolean,
|
|
makerAccountId: string,
|
|
takerAccountId: string,
|
|
makerPaymentMethodId: string,
|
|
takerPaymentMethodId: string,
|
|
makerPaymentAccountPayloadHash: Uint8Array | string,
|
|
takerPaymentAccountPayloadHash: Uint8Array | string,
|
|
makerPubKeyRing?: PubKeyRing.AsObject,
|
|
takerPubKeyRing?: PubKeyRing.AsObject,
|
|
buyerNodeAddress?: NodeAddress.AsObject,
|
|
sellerNodeAddress?: NodeAddress.AsObject,
|
|
makerPayoutAddressString: string,
|
|
takerPayoutAddressString: string,
|
|
arbitratorNodeAddress?: NodeAddress.AsObject,
|
|
lockTime: number,
|
|
makerDepositTxHash: string,
|
|
takerDepositTxHash: string,
|
|
}
|
|
}
|
|
|
|
export class RawTransactionInput extends jspb.Message {
|
|
getIndex(): number;
|
|
setIndex(value: number): RawTransactionInput;
|
|
|
|
getParentTransaction(): Uint8Array | string;
|
|
getParentTransaction_asU8(): Uint8Array;
|
|
getParentTransaction_asB64(): string;
|
|
setParentTransaction(value: Uint8Array | string): RawTransactionInput;
|
|
|
|
getValue(): number;
|
|
setValue(value: number): RawTransactionInput;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): RawTransactionInput.AsObject;
|
|
static toObject(includeInstance: boolean, msg: RawTransactionInput): RawTransactionInput.AsObject;
|
|
static serializeBinaryToWriter(message: RawTransactionInput, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): RawTransactionInput;
|
|
static deserializeBinaryFromReader(message: RawTransactionInput, reader: jspb.BinaryReader): RawTransactionInput;
|
|
}
|
|
|
|
export namespace RawTransactionInput {
|
|
export type AsObject = {
|
|
index: number,
|
|
parentTransaction: Uint8Array | string,
|
|
value: number,
|
|
}
|
|
}
|
|
|
|
export class PaymentAccountPayload extends jspb.Message {
|
|
getId(): string;
|
|
setId(value: string): PaymentAccountPayload;
|
|
|
|
getPaymentMethodId(): string;
|
|
setPaymentMethodId(value: string): PaymentAccountPayload;
|
|
|
|
getMaxTradePeriod(): number;
|
|
setMaxTradePeriod(value: number): PaymentAccountPayload;
|
|
|
|
getAliPayAccountPayload(): AliPayAccountPayload | undefined;
|
|
setAliPayAccountPayload(value?: AliPayAccountPayload): PaymentAccountPayload;
|
|
hasAliPayAccountPayload(): boolean;
|
|
clearAliPayAccountPayload(): PaymentAccountPayload;
|
|
|
|
getChaseQuickPayAccountPayload(): ChaseQuickPayAccountPayload | undefined;
|
|
setChaseQuickPayAccountPayload(value?: ChaseQuickPayAccountPayload): PaymentAccountPayload;
|
|
hasChaseQuickPayAccountPayload(): boolean;
|
|
clearChaseQuickPayAccountPayload(): PaymentAccountPayload;
|
|
|
|
getClearXchangeAccountPayload(): ClearXchangeAccountPayload | undefined;
|
|
setClearXchangeAccountPayload(value?: ClearXchangeAccountPayload): PaymentAccountPayload;
|
|
hasClearXchangeAccountPayload(): boolean;
|
|
clearClearXchangeAccountPayload(): PaymentAccountPayload;
|
|
|
|
getCountryBasedPaymentAccountPayload(): CountryBasedPaymentAccountPayload | undefined;
|
|
setCountryBasedPaymentAccountPayload(value?: CountryBasedPaymentAccountPayload): PaymentAccountPayload;
|
|
hasCountryBasedPaymentAccountPayload(): boolean;
|
|
clearCountryBasedPaymentAccountPayload(): PaymentAccountPayload;
|
|
|
|
getCryptoCurrencyAccountPayload(): CryptoCurrencyAccountPayload | undefined;
|
|
setCryptoCurrencyAccountPayload(value?: CryptoCurrencyAccountPayload): PaymentAccountPayload;
|
|
hasCryptoCurrencyAccountPayload(): boolean;
|
|
clearCryptoCurrencyAccountPayload(): PaymentAccountPayload;
|
|
|
|
getFasterPaymentsAccountPayload(): FasterPaymentsAccountPayload | undefined;
|
|
setFasterPaymentsAccountPayload(value?: FasterPaymentsAccountPayload): PaymentAccountPayload;
|
|
hasFasterPaymentsAccountPayload(): boolean;
|
|
clearFasterPaymentsAccountPayload(): PaymentAccountPayload;
|
|
|
|
getInteracETransferAccountPayload(): InteracETransferAccountPayload | undefined;
|
|
setInteracETransferAccountPayload(value?: InteracETransferAccountPayload): PaymentAccountPayload;
|
|
hasInteracETransferAccountPayload(): boolean;
|
|
clearInteracETransferAccountPayload(): PaymentAccountPayload;
|
|
|
|
getOKPayAccountPayload(): OKPayAccountPayload | undefined;
|
|
setOKPayAccountPayload(value?: OKPayAccountPayload): PaymentAccountPayload;
|
|
hasOKPayAccountPayload(): boolean;
|
|
clearOKPayAccountPayload(): PaymentAccountPayload;
|
|
|
|
getPerfectMoneyAccountPayload(): PerfectMoneyAccountPayload | undefined;
|
|
setPerfectMoneyAccountPayload(value?: PerfectMoneyAccountPayload): PaymentAccountPayload;
|
|
hasPerfectMoneyAccountPayload(): boolean;
|
|
clearPerfectMoneyAccountPayload(): PaymentAccountPayload;
|
|
|
|
getSwishAccountPayload(): SwishAccountPayload | undefined;
|
|
setSwishAccountPayload(value?: SwishAccountPayload): PaymentAccountPayload;
|
|
hasSwishAccountPayload(): boolean;
|
|
clearSwishAccountPayload(): PaymentAccountPayload;
|
|
|
|
getUSPostalMoneyOrderAccountPayload(): USPostalMoneyOrderAccountPayload | undefined;
|
|
setUSPostalMoneyOrderAccountPayload(value?: USPostalMoneyOrderAccountPayload): PaymentAccountPayload;
|
|
hasUSPostalMoneyOrderAccountPayload(): boolean;
|
|
clearUSPostalMoneyOrderAccountPayload(): PaymentAccountPayload;
|
|
|
|
getUpholdAccountPayload(): UpholdAccountPayload | undefined;
|
|
setUpholdAccountPayload(value?: UpholdAccountPayload): PaymentAccountPayload;
|
|
hasUpholdAccountPayload(): boolean;
|
|
clearUpholdAccountPayload(): PaymentAccountPayload;
|
|
|
|
getCashAppAccountPayload(): CashAppAccountPayload | undefined;
|
|
setCashAppAccountPayload(value?: CashAppAccountPayload): PaymentAccountPayload;
|
|
hasCashAppAccountPayload(): boolean;
|
|
clearCashAppAccountPayload(): PaymentAccountPayload;
|
|
|
|
getMoneyBeamAccountPayload(): MoneyBeamAccountPayload | undefined;
|
|
setMoneyBeamAccountPayload(value?: MoneyBeamAccountPayload): PaymentAccountPayload;
|
|
hasMoneyBeamAccountPayload(): boolean;
|
|
clearMoneyBeamAccountPayload(): PaymentAccountPayload;
|
|
|
|
getVenmoAccountPayload(): VenmoAccountPayload | undefined;
|
|
setVenmoAccountPayload(value?: VenmoAccountPayload): PaymentAccountPayload;
|
|
hasVenmoAccountPayload(): boolean;
|
|
clearVenmoAccountPayload(): PaymentAccountPayload;
|
|
|
|
getPopmoneyAccountPayload(): PopmoneyAccountPayload | undefined;
|
|
setPopmoneyAccountPayload(value?: PopmoneyAccountPayload): PaymentAccountPayload;
|
|
hasPopmoneyAccountPayload(): boolean;
|
|
clearPopmoneyAccountPayload(): PaymentAccountPayload;
|
|
|
|
getRevolutAccountPayload(): RevolutAccountPayload | undefined;
|
|
setRevolutAccountPayload(value?: RevolutAccountPayload): PaymentAccountPayload;
|
|
hasRevolutAccountPayload(): boolean;
|
|
clearRevolutAccountPayload(): PaymentAccountPayload;
|
|
|
|
getWeChatPayAccountPayload(): WeChatPayAccountPayload | undefined;
|
|
setWeChatPayAccountPayload(value?: WeChatPayAccountPayload): PaymentAccountPayload;
|
|
hasWeChatPayAccountPayload(): boolean;
|
|
clearWeChatPayAccountPayload(): PaymentAccountPayload;
|
|
|
|
getMoneyGramAccountPayload(): MoneyGramAccountPayload | undefined;
|
|
setMoneyGramAccountPayload(value?: MoneyGramAccountPayload): PaymentAccountPayload;
|
|
hasMoneyGramAccountPayload(): boolean;
|
|
clearMoneyGramAccountPayload(): PaymentAccountPayload;
|
|
|
|
getHalCashAccountPayload(): HalCashAccountPayload | undefined;
|
|
setHalCashAccountPayload(value?: HalCashAccountPayload): PaymentAccountPayload;
|
|
hasHalCashAccountPayload(): boolean;
|
|
clearHalCashAccountPayload(): PaymentAccountPayload;
|
|
|
|
getPromptPayAccountPayload(): PromptPayAccountPayload | undefined;
|
|
setPromptPayAccountPayload(value?: PromptPayAccountPayload): PaymentAccountPayload;
|
|
hasPromptPayAccountPayload(): boolean;
|
|
clearPromptPayAccountPayload(): PaymentAccountPayload;
|
|
|
|
getAdvancedCashAccountPayload(): AdvancedCashAccountPayload | undefined;
|
|
setAdvancedCashAccountPayload(value?: AdvancedCashAccountPayload): PaymentAccountPayload;
|
|
hasAdvancedCashAccountPayload(): boolean;
|
|
clearAdvancedCashAccountPayload(): PaymentAccountPayload;
|
|
|
|
getInstantCryptoCurrencyAccountPayload(): InstantCryptoCurrencyAccountPayload | undefined;
|
|
setInstantCryptoCurrencyAccountPayload(value?: InstantCryptoCurrencyAccountPayload): PaymentAccountPayload;
|
|
hasInstantCryptoCurrencyAccountPayload(): boolean;
|
|
clearInstantCryptoCurrencyAccountPayload(): PaymentAccountPayload;
|
|
|
|
getJapanBankAccountPayload(): JapanBankAccountPayload | undefined;
|
|
setJapanBankAccountPayload(value?: JapanBankAccountPayload): PaymentAccountPayload;
|
|
hasJapanBankAccountPayload(): boolean;
|
|
clearJapanBankAccountPayload(): PaymentAccountPayload;
|
|
|
|
getTransferwiseAccountPayload(): TransferwiseAccountPayload | undefined;
|
|
setTransferwiseAccountPayload(value?: TransferwiseAccountPayload): PaymentAccountPayload;
|
|
hasTransferwiseAccountPayload(): boolean;
|
|
clearTransferwiseAccountPayload(): PaymentAccountPayload;
|
|
|
|
getAustraliaPayidPayload(): AustraliaPayidPayload | undefined;
|
|
setAustraliaPayidPayload(value?: AustraliaPayidPayload): PaymentAccountPayload;
|
|
hasAustraliaPayidPayload(): boolean;
|
|
clearAustraliaPayidPayload(): PaymentAccountPayload;
|
|
|
|
getAmazonGiftCardAccountPayload(): AmazonGiftCardAccountPayload | undefined;
|
|
setAmazonGiftCardAccountPayload(value?: AmazonGiftCardAccountPayload): PaymentAccountPayload;
|
|
hasAmazonGiftCardAccountPayload(): boolean;
|
|
clearAmazonGiftCardAccountPayload(): PaymentAccountPayload;
|
|
|
|
getCashByMailAccountPayload(): CashByMailAccountPayload | undefined;
|
|
setCashByMailAccountPayload(value?: CashByMailAccountPayload): PaymentAccountPayload;
|
|
hasCashByMailAccountPayload(): boolean;
|
|
clearCashByMailAccountPayload(): PaymentAccountPayload;
|
|
|
|
getCapitualAccountPayload(): CapitualAccountPayload | undefined;
|
|
setCapitualAccountPayload(value?: CapitualAccountPayload): PaymentAccountPayload;
|
|
hasCapitualAccountPayload(): boolean;
|
|
clearCapitualAccountPayload(): PaymentAccountPayload;
|
|
|
|
getPayseraAccountPayload(): PayseraAccountPayload | undefined;
|
|
setPayseraAccountPayload(value?: PayseraAccountPayload): PaymentAccountPayload;
|
|
hasPayseraAccountPayload(): boolean;
|
|
clearPayseraAccountPayload(): PaymentAccountPayload;
|
|
|
|
getPaxumAccountPayload(): PaxumAccountPayload | undefined;
|
|
setPaxumAccountPayload(value?: PaxumAccountPayload): PaymentAccountPayload;
|
|
hasPaxumAccountPayload(): boolean;
|
|
clearPaxumAccountPayload(): PaymentAccountPayload;
|
|
|
|
getSwiftAccountPayload(): SwiftAccountPayload | undefined;
|
|
setSwiftAccountPayload(value?: SwiftAccountPayload): PaymentAccountPayload;
|
|
hasSwiftAccountPayload(): boolean;
|
|
clearSwiftAccountPayload(): PaymentAccountPayload;
|
|
|
|
getCelPayAccountPayload(): CelPayAccountPayload | undefined;
|
|
setCelPayAccountPayload(value?: CelPayAccountPayload): PaymentAccountPayload;
|
|
hasCelPayAccountPayload(): boolean;
|
|
clearCelPayAccountPayload(): PaymentAccountPayload;
|
|
|
|
getMoneseAccountPayload(): MoneseAccountPayload | undefined;
|
|
setMoneseAccountPayload(value?: MoneseAccountPayload): PaymentAccountPayload;
|
|
hasMoneseAccountPayload(): boolean;
|
|
clearMoneseAccountPayload(): PaymentAccountPayload;
|
|
|
|
getVerseAccountPayload(): VerseAccountPayload | undefined;
|
|
setVerseAccountPayload(value?: VerseAccountPayload): PaymentAccountPayload;
|
|
hasVerseAccountPayload(): boolean;
|
|
clearVerseAccountPayload(): PaymentAccountPayload;
|
|
|
|
getExcludeFromJsonDataMap(): jspb.Map<string, string>;
|
|
clearExcludeFromJsonDataMap(): PaymentAccountPayload;
|
|
|
|
getMessageCase(): PaymentAccountPayload.MessageCase;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PaymentAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PaymentAccountPayload): PaymentAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: PaymentAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PaymentAccountPayload;
|
|
static deserializeBinaryFromReader(message: PaymentAccountPayload, reader: jspb.BinaryReader): PaymentAccountPayload;
|
|
}
|
|
|
|
export namespace PaymentAccountPayload {
|
|
export type AsObject = {
|
|
id: string,
|
|
paymentMethodId: string,
|
|
maxTradePeriod: number,
|
|
aliPayAccountPayload?: AliPayAccountPayload.AsObject,
|
|
chaseQuickPayAccountPayload?: ChaseQuickPayAccountPayload.AsObject,
|
|
clearXchangeAccountPayload?: ClearXchangeAccountPayload.AsObject,
|
|
countryBasedPaymentAccountPayload?: CountryBasedPaymentAccountPayload.AsObject,
|
|
cryptoCurrencyAccountPayload?: CryptoCurrencyAccountPayload.AsObject,
|
|
fasterPaymentsAccountPayload?: FasterPaymentsAccountPayload.AsObject,
|
|
interacETransferAccountPayload?: InteracETransferAccountPayload.AsObject,
|
|
oKPayAccountPayload?: OKPayAccountPayload.AsObject,
|
|
perfectMoneyAccountPayload?: PerfectMoneyAccountPayload.AsObject,
|
|
swishAccountPayload?: SwishAccountPayload.AsObject,
|
|
uSPostalMoneyOrderAccountPayload?: USPostalMoneyOrderAccountPayload.AsObject,
|
|
upholdAccountPayload?: UpholdAccountPayload.AsObject,
|
|
cashAppAccountPayload?: CashAppAccountPayload.AsObject,
|
|
moneyBeamAccountPayload?: MoneyBeamAccountPayload.AsObject,
|
|
venmoAccountPayload?: VenmoAccountPayload.AsObject,
|
|
popmoneyAccountPayload?: PopmoneyAccountPayload.AsObject,
|
|
revolutAccountPayload?: RevolutAccountPayload.AsObject,
|
|
weChatPayAccountPayload?: WeChatPayAccountPayload.AsObject,
|
|
moneyGramAccountPayload?: MoneyGramAccountPayload.AsObject,
|
|
halCashAccountPayload?: HalCashAccountPayload.AsObject,
|
|
promptPayAccountPayload?: PromptPayAccountPayload.AsObject,
|
|
advancedCashAccountPayload?: AdvancedCashAccountPayload.AsObject,
|
|
instantCryptoCurrencyAccountPayload?: InstantCryptoCurrencyAccountPayload.AsObject,
|
|
japanBankAccountPayload?: JapanBankAccountPayload.AsObject,
|
|
transferwiseAccountPayload?: TransferwiseAccountPayload.AsObject,
|
|
australiaPayidPayload?: AustraliaPayidPayload.AsObject,
|
|
amazonGiftCardAccountPayload?: AmazonGiftCardAccountPayload.AsObject,
|
|
cashByMailAccountPayload?: CashByMailAccountPayload.AsObject,
|
|
capitualAccountPayload?: CapitualAccountPayload.AsObject,
|
|
payseraAccountPayload?: PayseraAccountPayload.AsObject,
|
|
paxumAccountPayload?: PaxumAccountPayload.AsObject,
|
|
swiftAccountPayload?: SwiftAccountPayload.AsObject,
|
|
celPayAccountPayload?: CelPayAccountPayload.AsObject,
|
|
moneseAccountPayload?: MoneseAccountPayload.AsObject,
|
|
verseAccountPayload?: VerseAccountPayload.AsObject,
|
|
excludeFromJsonDataMap: Array<[string, string]>,
|
|
}
|
|
|
|
export enum MessageCase {
|
|
MESSAGE_NOT_SET = 0,
|
|
ALI_PAY_ACCOUNT_PAYLOAD = 4,
|
|
CHASE_QUICK_PAY_ACCOUNT_PAYLOAD = 5,
|
|
CLEAR_XCHANGE_ACCOUNT_PAYLOAD = 6,
|
|
COUNTRY_BASED_PAYMENT_ACCOUNT_PAYLOAD = 7,
|
|
CRYPTO_CURRENCY_ACCOUNT_PAYLOAD = 8,
|
|
FASTER_PAYMENTS_ACCOUNT_PAYLOAD = 9,
|
|
INTERAC_E_TRANSFER_ACCOUNT_PAYLOAD = 10,
|
|
O_K_PAY_ACCOUNT_PAYLOAD = 11,
|
|
PERFECT_MONEY_ACCOUNT_PAYLOAD = 12,
|
|
SWISH_ACCOUNT_PAYLOAD = 13,
|
|
U_S_POSTAL_MONEY_ORDER_ACCOUNT_PAYLOAD = 14,
|
|
UPHOLD_ACCOUNT_PAYLOAD = 16,
|
|
CASH_APP_ACCOUNT_PAYLOAD = 17,
|
|
MONEY_BEAM_ACCOUNT_PAYLOAD = 18,
|
|
VENMO_ACCOUNT_PAYLOAD = 19,
|
|
POPMONEY_ACCOUNT_PAYLOAD = 20,
|
|
REVOLUT_ACCOUNT_PAYLOAD = 21,
|
|
WE_CHAT_PAY_ACCOUNT_PAYLOAD = 22,
|
|
MONEY_GRAM_ACCOUNT_PAYLOAD = 23,
|
|
HAL_CASH_ACCOUNT_PAYLOAD = 24,
|
|
PROMPT_PAY_ACCOUNT_PAYLOAD = 25,
|
|
ADVANCED_CASH_ACCOUNT_PAYLOAD = 26,
|
|
INSTANT_CRYPTO_CURRENCY_ACCOUNT_PAYLOAD = 27,
|
|
JAPAN_BANK_ACCOUNT_PAYLOAD = 28,
|
|
TRANSFERWISE_ACCOUNT_PAYLOAD = 29,
|
|
AUSTRALIA_PAYID_PAYLOAD = 30,
|
|
AMAZON_GIFT_CARD_ACCOUNT_PAYLOAD = 31,
|
|
CASH_BY_MAIL_ACCOUNT_PAYLOAD = 32,
|
|
CAPITUAL_ACCOUNT_PAYLOAD = 33,
|
|
PAYSERA_ACCOUNT_PAYLOAD = 34,
|
|
PAXUM_ACCOUNT_PAYLOAD = 35,
|
|
SWIFT_ACCOUNT_PAYLOAD = 36,
|
|
CEL_PAY_ACCOUNT_PAYLOAD = 37,
|
|
MONESE_ACCOUNT_PAYLOAD = 38,
|
|
VERSE_ACCOUNT_PAYLOAD = 39,
|
|
}
|
|
}
|
|
|
|
export class AliPayAccountPayload extends jspb.Message {
|
|
getAccountNr(): string;
|
|
setAccountNr(value: string): AliPayAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): AliPayAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: AliPayAccountPayload): AliPayAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: AliPayAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): AliPayAccountPayload;
|
|
static deserializeBinaryFromReader(message: AliPayAccountPayload, reader: jspb.BinaryReader): AliPayAccountPayload;
|
|
}
|
|
|
|
export namespace AliPayAccountPayload {
|
|
export type AsObject = {
|
|
accountNr: string,
|
|
}
|
|
}
|
|
|
|
export class WeChatPayAccountPayload extends jspb.Message {
|
|
getAccountNr(): string;
|
|
setAccountNr(value: string): WeChatPayAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): WeChatPayAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: WeChatPayAccountPayload): WeChatPayAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: WeChatPayAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): WeChatPayAccountPayload;
|
|
static deserializeBinaryFromReader(message: WeChatPayAccountPayload, reader: jspb.BinaryReader): WeChatPayAccountPayload;
|
|
}
|
|
|
|
export namespace WeChatPayAccountPayload {
|
|
export type AsObject = {
|
|
accountNr: string,
|
|
}
|
|
}
|
|
|
|
export class ChaseQuickPayAccountPayload extends jspb.Message {
|
|
getEmail(): string;
|
|
setEmail(value: string): ChaseQuickPayAccountPayload;
|
|
|
|
getHolderName(): string;
|
|
setHolderName(value: string): ChaseQuickPayAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): ChaseQuickPayAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: ChaseQuickPayAccountPayload): ChaseQuickPayAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: ChaseQuickPayAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): ChaseQuickPayAccountPayload;
|
|
static deserializeBinaryFromReader(message: ChaseQuickPayAccountPayload, reader: jspb.BinaryReader): ChaseQuickPayAccountPayload;
|
|
}
|
|
|
|
export namespace ChaseQuickPayAccountPayload {
|
|
export type AsObject = {
|
|
email: string,
|
|
holderName: string,
|
|
}
|
|
}
|
|
|
|
export class ClearXchangeAccountPayload extends jspb.Message {
|
|
getHolderName(): string;
|
|
setHolderName(value: string): ClearXchangeAccountPayload;
|
|
|
|
getEmailOrMobileNr(): string;
|
|
setEmailOrMobileNr(value: string): ClearXchangeAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): ClearXchangeAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: ClearXchangeAccountPayload): ClearXchangeAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: ClearXchangeAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): ClearXchangeAccountPayload;
|
|
static deserializeBinaryFromReader(message: ClearXchangeAccountPayload, reader: jspb.BinaryReader): ClearXchangeAccountPayload;
|
|
}
|
|
|
|
export namespace ClearXchangeAccountPayload {
|
|
export type AsObject = {
|
|
holderName: string,
|
|
emailOrMobileNr: string,
|
|
}
|
|
}
|
|
|
|
export class CountryBasedPaymentAccountPayload extends jspb.Message {
|
|
getCountryCode(): string;
|
|
setCountryCode(value: string): CountryBasedPaymentAccountPayload;
|
|
|
|
getAcceptedCountryCodesList(): Array<string>;
|
|
setAcceptedCountryCodesList(value: Array<string>): CountryBasedPaymentAccountPayload;
|
|
clearAcceptedCountryCodesList(): CountryBasedPaymentAccountPayload;
|
|
addAcceptedCountryCodes(value: string, index?: number): CountryBasedPaymentAccountPayload;
|
|
|
|
getBankAccountPayload(): BankAccountPayload | undefined;
|
|
setBankAccountPayload(value?: BankAccountPayload): CountryBasedPaymentAccountPayload;
|
|
hasBankAccountPayload(): boolean;
|
|
clearBankAccountPayload(): CountryBasedPaymentAccountPayload;
|
|
|
|
getCashDepositAccountPayload(): CashDepositAccountPayload | undefined;
|
|
setCashDepositAccountPayload(value?: CashDepositAccountPayload): CountryBasedPaymentAccountPayload;
|
|
hasCashDepositAccountPayload(): boolean;
|
|
clearCashDepositAccountPayload(): CountryBasedPaymentAccountPayload;
|
|
|
|
getSepaAccountPayload(): SepaAccountPayload | undefined;
|
|
setSepaAccountPayload(value?: SepaAccountPayload): CountryBasedPaymentAccountPayload;
|
|
hasSepaAccountPayload(): boolean;
|
|
clearSepaAccountPayload(): CountryBasedPaymentAccountPayload;
|
|
|
|
getWesternUnionAccountPayload(): WesternUnionAccountPayload | undefined;
|
|
setWesternUnionAccountPayload(value?: WesternUnionAccountPayload): CountryBasedPaymentAccountPayload;
|
|
hasWesternUnionAccountPayload(): boolean;
|
|
clearWesternUnionAccountPayload(): CountryBasedPaymentAccountPayload;
|
|
|
|
getSepaInstantAccountPayload(): SepaInstantAccountPayload | undefined;
|
|
setSepaInstantAccountPayload(value?: SepaInstantAccountPayload): CountryBasedPaymentAccountPayload;
|
|
hasSepaInstantAccountPayload(): boolean;
|
|
clearSepaInstantAccountPayload(): CountryBasedPaymentAccountPayload;
|
|
|
|
getF2fAccountPayload(): F2FAccountPayload | undefined;
|
|
setF2fAccountPayload(value?: F2FAccountPayload): CountryBasedPaymentAccountPayload;
|
|
hasF2fAccountPayload(): boolean;
|
|
clearF2fAccountPayload(): CountryBasedPaymentAccountPayload;
|
|
|
|
getUpiAccountPayload(): UpiAccountPayload | undefined;
|
|
setUpiAccountPayload(value?: UpiAccountPayload): CountryBasedPaymentAccountPayload;
|
|
hasUpiAccountPayload(): boolean;
|
|
clearUpiAccountPayload(): CountryBasedPaymentAccountPayload;
|
|
|
|
getPaytmAccountPayload(): PaytmAccountPayload | undefined;
|
|
setPaytmAccountPayload(value?: PaytmAccountPayload): CountryBasedPaymentAccountPayload;
|
|
hasPaytmAccountPayload(): boolean;
|
|
clearPaytmAccountPayload(): CountryBasedPaymentAccountPayload;
|
|
|
|
getIfscBasedAccountPayload(): IfscBasedAccountPayload | undefined;
|
|
setIfscBasedAccountPayload(value?: IfscBasedAccountPayload): CountryBasedPaymentAccountPayload;
|
|
hasIfscBasedAccountPayload(): boolean;
|
|
clearIfscBasedAccountPayload(): CountryBasedPaymentAccountPayload;
|
|
|
|
getNequiAccountPayload(): NequiAccountPayload | undefined;
|
|
setNequiAccountPayload(value?: NequiAccountPayload): CountryBasedPaymentAccountPayload;
|
|
hasNequiAccountPayload(): boolean;
|
|
clearNequiAccountPayload(): CountryBasedPaymentAccountPayload;
|
|
|
|
getBizumAccountPayload(): BizumAccountPayload | undefined;
|
|
setBizumAccountPayload(value?: BizumAccountPayload): CountryBasedPaymentAccountPayload;
|
|
hasBizumAccountPayload(): boolean;
|
|
clearBizumAccountPayload(): CountryBasedPaymentAccountPayload;
|
|
|
|
getPixAccountPayload(): PixAccountPayload | undefined;
|
|
setPixAccountPayload(value?: PixAccountPayload): CountryBasedPaymentAccountPayload;
|
|
hasPixAccountPayload(): boolean;
|
|
clearPixAccountPayload(): CountryBasedPaymentAccountPayload;
|
|
|
|
getSatispayAccountPayload(): SatispayAccountPayload | undefined;
|
|
setSatispayAccountPayload(value?: SatispayAccountPayload): CountryBasedPaymentAccountPayload;
|
|
hasSatispayAccountPayload(): boolean;
|
|
clearSatispayAccountPayload(): CountryBasedPaymentAccountPayload;
|
|
|
|
getStrikeAccountPayload(): StrikeAccountPayload | undefined;
|
|
setStrikeAccountPayload(value?: StrikeAccountPayload): CountryBasedPaymentAccountPayload;
|
|
hasStrikeAccountPayload(): boolean;
|
|
clearStrikeAccountPayload(): CountryBasedPaymentAccountPayload;
|
|
|
|
getTikkieAccountPayload(): TikkieAccountPayload | undefined;
|
|
setTikkieAccountPayload(value?: TikkieAccountPayload): CountryBasedPaymentAccountPayload;
|
|
hasTikkieAccountPayload(): boolean;
|
|
clearTikkieAccountPayload(): CountryBasedPaymentAccountPayload;
|
|
|
|
getTransferwiseUsdAccountPayload(): TransferwiseUsdAccountPayload | undefined;
|
|
setTransferwiseUsdAccountPayload(value?: TransferwiseUsdAccountPayload): CountryBasedPaymentAccountPayload;
|
|
hasTransferwiseUsdAccountPayload(): boolean;
|
|
clearTransferwiseUsdAccountPayload(): CountryBasedPaymentAccountPayload;
|
|
|
|
getSwiftAccountPayload(): SwiftAccountPayload | undefined;
|
|
setSwiftAccountPayload(value?: SwiftAccountPayload): CountryBasedPaymentAccountPayload;
|
|
hasSwiftAccountPayload(): boolean;
|
|
clearSwiftAccountPayload(): CountryBasedPaymentAccountPayload;
|
|
|
|
getMessageCase(): CountryBasedPaymentAccountPayload.MessageCase;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): CountryBasedPaymentAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: CountryBasedPaymentAccountPayload): CountryBasedPaymentAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: CountryBasedPaymentAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): CountryBasedPaymentAccountPayload;
|
|
static deserializeBinaryFromReader(message: CountryBasedPaymentAccountPayload, reader: jspb.BinaryReader): CountryBasedPaymentAccountPayload;
|
|
}
|
|
|
|
export namespace CountryBasedPaymentAccountPayload {
|
|
export type AsObject = {
|
|
countryCode: string,
|
|
acceptedCountryCodesList: Array<string>,
|
|
bankAccountPayload?: BankAccountPayload.AsObject,
|
|
cashDepositAccountPayload?: CashDepositAccountPayload.AsObject,
|
|
sepaAccountPayload?: SepaAccountPayload.AsObject,
|
|
westernUnionAccountPayload?: WesternUnionAccountPayload.AsObject,
|
|
sepaInstantAccountPayload?: SepaInstantAccountPayload.AsObject,
|
|
f2fAccountPayload?: F2FAccountPayload.AsObject,
|
|
upiAccountPayload?: UpiAccountPayload.AsObject,
|
|
paytmAccountPayload?: PaytmAccountPayload.AsObject,
|
|
ifscBasedAccountPayload?: IfscBasedAccountPayload.AsObject,
|
|
nequiAccountPayload?: NequiAccountPayload.AsObject,
|
|
bizumAccountPayload?: BizumAccountPayload.AsObject,
|
|
pixAccountPayload?: PixAccountPayload.AsObject,
|
|
satispayAccountPayload?: SatispayAccountPayload.AsObject,
|
|
strikeAccountPayload?: StrikeAccountPayload.AsObject,
|
|
tikkieAccountPayload?: TikkieAccountPayload.AsObject,
|
|
transferwiseUsdAccountPayload?: TransferwiseUsdAccountPayload.AsObject,
|
|
swiftAccountPayload?: SwiftAccountPayload.AsObject,
|
|
}
|
|
|
|
export enum MessageCase {
|
|
MESSAGE_NOT_SET = 0,
|
|
BANK_ACCOUNT_PAYLOAD = 3,
|
|
CASH_DEPOSIT_ACCOUNT_PAYLOAD = 4,
|
|
SEPA_ACCOUNT_PAYLOAD = 5,
|
|
WESTERN_UNION_ACCOUNT_PAYLOAD = 6,
|
|
SEPA_INSTANT_ACCOUNT_PAYLOAD = 7,
|
|
F2F_ACCOUNT_PAYLOAD = 8,
|
|
UPI_ACCOUNT_PAYLOAD = 9,
|
|
PAYTM_ACCOUNT_PAYLOAD = 10,
|
|
IFSC_BASED_ACCOUNT_PAYLOAD = 11,
|
|
NEQUI_ACCOUNT_PAYLOAD = 12,
|
|
BIZUM_ACCOUNT_PAYLOAD = 13,
|
|
PIX_ACCOUNT_PAYLOAD = 14,
|
|
SATISPAY_ACCOUNT_PAYLOAD = 15,
|
|
STRIKE_ACCOUNT_PAYLOAD = 16,
|
|
TIKKIE_ACCOUNT_PAYLOAD = 17,
|
|
TRANSFERWISE_USD_ACCOUNT_PAYLOAD = 18,
|
|
SWIFT_ACCOUNT_PAYLOAD = 19,
|
|
}
|
|
}
|
|
|
|
export class BankAccountPayload extends jspb.Message {
|
|
getHolderName(): string;
|
|
setHolderName(value: string): BankAccountPayload;
|
|
|
|
getBankName(): string;
|
|
setBankName(value: string): BankAccountPayload;
|
|
|
|
getBankId(): string;
|
|
setBankId(value: string): BankAccountPayload;
|
|
|
|
getBranchId(): string;
|
|
setBranchId(value: string): BankAccountPayload;
|
|
|
|
getAccountNr(): string;
|
|
setAccountNr(value: string): BankAccountPayload;
|
|
|
|
getAccountType(): string;
|
|
setAccountType(value: string): BankAccountPayload;
|
|
|
|
getHolderTaxId(): string;
|
|
setHolderTaxId(value: string): BankAccountPayload;
|
|
|
|
getEmail(): string;
|
|
setEmail(value: string): BankAccountPayload;
|
|
|
|
getNationalBankAccountPayload(): NationalBankAccountPayload | undefined;
|
|
setNationalBankAccountPayload(value?: NationalBankAccountPayload): BankAccountPayload;
|
|
hasNationalBankAccountPayload(): boolean;
|
|
clearNationalBankAccountPayload(): BankAccountPayload;
|
|
|
|
getSameBankAccontPayload(): SameBankAccountPayload | undefined;
|
|
setSameBankAccontPayload(value?: SameBankAccountPayload): BankAccountPayload;
|
|
hasSameBankAccontPayload(): boolean;
|
|
clearSameBankAccontPayload(): BankAccountPayload;
|
|
|
|
getSpecificBanksAccountPayload(): SpecificBanksAccountPayload | undefined;
|
|
setSpecificBanksAccountPayload(value?: SpecificBanksAccountPayload): BankAccountPayload;
|
|
hasSpecificBanksAccountPayload(): boolean;
|
|
clearSpecificBanksAccountPayload(): BankAccountPayload;
|
|
|
|
getAchTransferAccountPayload(): AchTransferAccountPayload | undefined;
|
|
setAchTransferAccountPayload(value?: AchTransferAccountPayload): BankAccountPayload;
|
|
hasAchTransferAccountPayload(): boolean;
|
|
clearAchTransferAccountPayload(): BankAccountPayload;
|
|
|
|
getDomesticWireTransferAccountPayload(): DomesticWireTransferAccountPayload | undefined;
|
|
setDomesticWireTransferAccountPayload(value?: DomesticWireTransferAccountPayload): BankAccountPayload;
|
|
hasDomesticWireTransferAccountPayload(): boolean;
|
|
clearDomesticWireTransferAccountPayload(): BankAccountPayload;
|
|
|
|
getNationalAccountId(): string;
|
|
setNationalAccountId(value: string): BankAccountPayload;
|
|
|
|
getMessageCase(): BankAccountPayload.MessageCase;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): BankAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: BankAccountPayload): BankAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: BankAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): BankAccountPayload;
|
|
static deserializeBinaryFromReader(message: BankAccountPayload, reader: jspb.BinaryReader): BankAccountPayload;
|
|
}
|
|
|
|
export namespace BankAccountPayload {
|
|
export type AsObject = {
|
|
holderName: string,
|
|
bankName: string,
|
|
bankId: string,
|
|
branchId: string,
|
|
accountNr: string,
|
|
accountType: string,
|
|
holderTaxId: string,
|
|
email: string,
|
|
nationalBankAccountPayload?: NationalBankAccountPayload.AsObject,
|
|
sameBankAccontPayload?: SameBankAccountPayload.AsObject,
|
|
specificBanksAccountPayload?: SpecificBanksAccountPayload.AsObject,
|
|
achTransferAccountPayload?: AchTransferAccountPayload.AsObject,
|
|
domesticWireTransferAccountPayload?: DomesticWireTransferAccountPayload.AsObject,
|
|
nationalAccountId: string,
|
|
}
|
|
|
|
export enum MessageCase {
|
|
MESSAGE_NOT_SET = 0,
|
|
NATIONAL_BANK_ACCOUNT_PAYLOAD = 9,
|
|
SAME_BANK_ACCONT_PAYLOAD = 10,
|
|
SPECIFIC_BANKS_ACCOUNT_PAYLOAD = 11,
|
|
ACH_TRANSFER_ACCOUNT_PAYLOAD = 13,
|
|
DOMESTIC_WIRE_TRANSFER_ACCOUNT_PAYLOAD = 14,
|
|
}
|
|
}
|
|
|
|
export class AchTransferAccountPayload extends jspb.Message {
|
|
getHolderAddress(): string;
|
|
setHolderAddress(value: string): AchTransferAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): AchTransferAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: AchTransferAccountPayload): AchTransferAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: AchTransferAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): AchTransferAccountPayload;
|
|
static deserializeBinaryFromReader(message: AchTransferAccountPayload, reader: jspb.BinaryReader): AchTransferAccountPayload;
|
|
}
|
|
|
|
export namespace AchTransferAccountPayload {
|
|
export type AsObject = {
|
|
holderAddress: string,
|
|
}
|
|
}
|
|
|
|
export class DomesticWireTransferAccountPayload extends jspb.Message {
|
|
getHolderAddress(): string;
|
|
setHolderAddress(value: string): DomesticWireTransferAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): DomesticWireTransferAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: DomesticWireTransferAccountPayload): DomesticWireTransferAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: DomesticWireTransferAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): DomesticWireTransferAccountPayload;
|
|
static deserializeBinaryFromReader(message: DomesticWireTransferAccountPayload, reader: jspb.BinaryReader): DomesticWireTransferAccountPayload;
|
|
}
|
|
|
|
export namespace DomesticWireTransferAccountPayload {
|
|
export type AsObject = {
|
|
holderAddress: string,
|
|
}
|
|
}
|
|
|
|
export class NationalBankAccountPayload extends jspb.Message {
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): NationalBankAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: NationalBankAccountPayload): NationalBankAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: NationalBankAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): NationalBankAccountPayload;
|
|
static deserializeBinaryFromReader(message: NationalBankAccountPayload, reader: jspb.BinaryReader): NationalBankAccountPayload;
|
|
}
|
|
|
|
export namespace NationalBankAccountPayload {
|
|
export type AsObject = {
|
|
}
|
|
}
|
|
|
|
export class SameBankAccountPayload extends jspb.Message {
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): SameBankAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: SameBankAccountPayload): SameBankAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: SameBankAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): SameBankAccountPayload;
|
|
static deserializeBinaryFromReader(message: SameBankAccountPayload, reader: jspb.BinaryReader): SameBankAccountPayload;
|
|
}
|
|
|
|
export namespace SameBankAccountPayload {
|
|
export type AsObject = {
|
|
}
|
|
}
|
|
|
|
export class JapanBankAccountPayload extends jspb.Message {
|
|
getBankName(): string;
|
|
setBankName(value: string): JapanBankAccountPayload;
|
|
|
|
getBankCode(): string;
|
|
setBankCode(value: string): JapanBankAccountPayload;
|
|
|
|
getBankBranchName(): string;
|
|
setBankBranchName(value: string): JapanBankAccountPayload;
|
|
|
|
getBankBranchCode(): string;
|
|
setBankBranchCode(value: string): JapanBankAccountPayload;
|
|
|
|
getBankAccountType(): string;
|
|
setBankAccountType(value: string): JapanBankAccountPayload;
|
|
|
|
getBankAccountName(): string;
|
|
setBankAccountName(value: string): JapanBankAccountPayload;
|
|
|
|
getBankAccountNumber(): string;
|
|
setBankAccountNumber(value: string): JapanBankAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): JapanBankAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: JapanBankAccountPayload): JapanBankAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: JapanBankAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): JapanBankAccountPayload;
|
|
static deserializeBinaryFromReader(message: JapanBankAccountPayload, reader: jspb.BinaryReader): JapanBankAccountPayload;
|
|
}
|
|
|
|
export namespace JapanBankAccountPayload {
|
|
export type AsObject = {
|
|
bankName: string,
|
|
bankCode: string,
|
|
bankBranchName: string,
|
|
bankBranchCode: string,
|
|
bankAccountType: string,
|
|
bankAccountName: string,
|
|
bankAccountNumber: string,
|
|
}
|
|
}
|
|
|
|
export class AustraliaPayidPayload extends jspb.Message {
|
|
getBankAccountName(): string;
|
|
setBankAccountName(value: string): AustraliaPayidPayload;
|
|
|
|
getPayid(): string;
|
|
setPayid(value: string): AustraliaPayidPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): AustraliaPayidPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: AustraliaPayidPayload): AustraliaPayidPayload.AsObject;
|
|
static serializeBinaryToWriter(message: AustraliaPayidPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): AustraliaPayidPayload;
|
|
static deserializeBinaryFromReader(message: AustraliaPayidPayload, reader: jspb.BinaryReader): AustraliaPayidPayload;
|
|
}
|
|
|
|
export namespace AustraliaPayidPayload {
|
|
export type AsObject = {
|
|
bankAccountName: string,
|
|
payid: string,
|
|
}
|
|
}
|
|
|
|
export class SpecificBanksAccountPayload extends jspb.Message {
|
|
getAcceptedBanksList(): Array<string>;
|
|
setAcceptedBanksList(value: Array<string>): SpecificBanksAccountPayload;
|
|
clearAcceptedBanksList(): SpecificBanksAccountPayload;
|
|
addAcceptedBanks(value: string, index?: number): SpecificBanksAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): SpecificBanksAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: SpecificBanksAccountPayload): SpecificBanksAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: SpecificBanksAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): SpecificBanksAccountPayload;
|
|
static deserializeBinaryFromReader(message: SpecificBanksAccountPayload, reader: jspb.BinaryReader): SpecificBanksAccountPayload;
|
|
}
|
|
|
|
export namespace SpecificBanksAccountPayload {
|
|
export type AsObject = {
|
|
acceptedBanksList: Array<string>,
|
|
}
|
|
}
|
|
|
|
export class CashDepositAccountPayload extends jspb.Message {
|
|
getHolderName(): string;
|
|
setHolderName(value: string): CashDepositAccountPayload;
|
|
|
|
getHolderEmail(): string;
|
|
setHolderEmail(value: string): CashDepositAccountPayload;
|
|
|
|
getBankName(): string;
|
|
setBankName(value: string): CashDepositAccountPayload;
|
|
|
|
getBankId(): string;
|
|
setBankId(value: string): CashDepositAccountPayload;
|
|
|
|
getBranchId(): string;
|
|
setBranchId(value: string): CashDepositAccountPayload;
|
|
|
|
getAccountNr(): string;
|
|
setAccountNr(value: string): CashDepositAccountPayload;
|
|
|
|
getAccountType(): string;
|
|
setAccountType(value: string): CashDepositAccountPayload;
|
|
|
|
getRequirements(): string;
|
|
setRequirements(value: string): CashDepositAccountPayload;
|
|
|
|
getHolderTaxId(): string;
|
|
setHolderTaxId(value: string): CashDepositAccountPayload;
|
|
|
|
getNationalAccountId(): string;
|
|
setNationalAccountId(value: string): CashDepositAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): CashDepositAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: CashDepositAccountPayload): CashDepositAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: CashDepositAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): CashDepositAccountPayload;
|
|
static deserializeBinaryFromReader(message: CashDepositAccountPayload, reader: jspb.BinaryReader): CashDepositAccountPayload;
|
|
}
|
|
|
|
export namespace CashDepositAccountPayload {
|
|
export type AsObject = {
|
|
holderName: string,
|
|
holderEmail: string,
|
|
bankName: string,
|
|
bankId: string,
|
|
branchId: string,
|
|
accountNr: string,
|
|
accountType: string,
|
|
requirements: string,
|
|
holderTaxId: string,
|
|
nationalAccountId: string,
|
|
}
|
|
}
|
|
|
|
export class MoneyGramAccountPayload extends jspb.Message {
|
|
getHolderName(): string;
|
|
setHolderName(value: string): MoneyGramAccountPayload;
|
|
|
|
getCountryCode(): string;
|
|
setCountryCode(value: string): MoneyGramAccountPayload;
|
|
|
|
getState(): string;
|
|
setState(value: string): MoneyGramAccountPayload;
|
|
|
|
getEmail(): string;
|
|
setEmail(value: string): MoneyGramAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): MoneyGramAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: MoneyGramAccountPayload): MoneyGramAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: MoneyGramAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): MoneyGramAccountPayload;
|
|
static deserializeBinaryFromReader(message: MoneyGramAccountPayload, reader: jspb.BinaryReader): MoneyGramAccountPayload;
|
|
}
|
|
|
|
export namespace MoneyGramAccountPayload {
|
|
export type AsObject = {
|
|
holderName: string,
|
|
countryCode: string,
|
|
state: string,
|
|
email: string,
|
|
}
|
|
}
|
|
|
|
export class HalCashAccountPayload extends jspb.Message {
|
|
getMobileNr(): string;
|
|
setMobileNr(value: string): HalCashAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): HalCashAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: HalCashAccountPayload): HalCashAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: HalCashAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): HalCashAccountPayload;
|
|
static deserializeBinaryFromReader(message: HalCashAccountPayload, reader: jspb.BinaryReader): HalCashAccountPayload;
|
|
}
|
|
|
|
export namespace HalCashAccountPayload {
|
|
export type AsObject = {
|
|
mobileNr: string,
|
|
}
|
|
}
|
|
|
|
export class WesternUnionAccountPayload extends jspb.Message {
|
|
getHolderName(): string;
|
|
setHolderName(value: string): WesternUnionAccountPayload;
|
|
|
|
getCity(): string;
|
|
setCity(value: string): WesternUnionAccountPayload;
|
|
|
|
getState(): string;
|
|
setState(value: string): WesternUnionAccountPayload;
|
|
|
|
getEmail(): string;
|
|
setEmail(value: string): WesternUnionAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): WesternUnionAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: WesternUnionAccountPayload): WesternUnionAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: WesternUnionAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): WesternUnionAccountPayload;
|
|
static deserializeBinaryFromReader(message: WesternUnionAccountPayload, reader: jspb.BinaryReader): WesternUnionAccountPayload;
|
|
}
|
|
|
|
export namespace WesternUnionAccountPayload {
|
|
export type AsObject = {
|
|
holderName: string,
|
|
city: string,
|
|
state: string,
|
|
email: string,
|
|
}
|
|
}
|
|
|
|
export class AmazonGiftCardAccountPayload extends jspb.Message {
|
|
getEmailOrMobileNr(): string;
|
|
setEmailOrMobileNr(value: string): AmazonGiftCardAccountPayload;
|
|
|
|
getCountryCode(): string;
|
|
setCountryCode(value: string): AmazonGiftCardAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): AmazonGiftCardAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: AmazonGiftCardAccountPayload): AmazonGiftCardAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: AmazonGiftCardAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): AmazonGiftCardAccountPayload;
|
|
static deserializeBinaryFromReader(message: AmazonGiftCardAccountPayload, reader: jspb.BinaryReader): AmazonGiftCardAccountPayload;
|
|
}
|
|
|
|
export namespace AmazonGiftCardAccountPayload {
|
|
export type AsObject = {
|
|
emailOrMobileNr: string,
|
|
countryCode: string,
|
|
}
|
|
}
|
|
|
|
export class SepaAccountPayload extends jspb.Message {
|
|
getHolderName(): string;
|
|
setHolderName(value: string): SepaAccountPayload;
|
|
|
|
getIban(): string;
|
|
setIban(value: string): SepaAccountPayload;
|
|
|
|
getBic(): string;
|
|
setBic(value: string): SepaAccountPayload;
|
|
|
|
getEmail(): string;
|
|
setEmail(value: string): SepaAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): SepaAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: SepaAccountPayload): SepaAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: SepaAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): SepaAccountPayload;
|
|
static deserializeBinaryFromReader(message: SepaAccountPayload, reader: jspb.BinaryReader): SepaAccountPayload;
|
|
}
|
|
|
|
export namespace SepaAccountPayload {
|
|
export type AsObject = {
|
|
holderName: string,
|
|
iban: string,
|
|
bic: string,
|
|
email: string,
|
|
}
|
|
}
|
|
|
|
export class SepaInstantAccountPayload extends jspb.Message {
|
|
getHolderName(): string;
|
|
setHolderName(value: string): SepaInstantAccountPayload;
|
|
|
|
getIban(): string;
|
|
setIban(value: string): SepaInstantAccountPayload;
|
|
|
|
getBic(): string;
|
|
setBic(value: string): SepaInstantAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): SepaInstantAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: SepaInstantAccountPayload): SepaInstantAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: SepaInstantAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): SepaInstantAccountPayload;
|
|
static deserializeBinaryFromReader(message: SepaInstantAccountPayload, reader: jspb.BinaryReader): SepaInstantAccountPayload;
|
|
}
|
|
|
|
export namespace SepaInstantAccountPayload {
|
|
export type AsObject = {
|
|
holderName: string,
|
|
iban: string,
|
|
bic: string,
|
|
}
|
|
}
|
|
|
|
export class CryptoCurrencyAccountPayload extends jspb.Message {
|
|
getAddress(): string;
|
|
setAddress(value: string): CryptoCurrencyAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): CryptoCurrencyAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: CryptoCurrencyAccountPayload): CryptoCurrencyAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: CryptoCurrencyAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): CryptoCurrencyAccountPayload;
|
|
static deserializeBinaryFromReader(message: CryptoCurrencyAccountPayload, reader: jspb.BinaryReader): CryptoCurrencyAccountPayload;
|
|
}
|
|
|
|
export namespace CryptoCurrencyAccountPayload {
|
|
export type AsObject = {
|
|
address: string,
|
|
}
|
|
}
|
|
|
|
export class InstantCryptoCurrencyAccountPayload extends jspb.Message {
|
|
getAddress(): string;
|
|
setAddress(value: string): InstantCryptoCurrencyAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): InstantCryptoCurrencyAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: InstantCryptoCurrencyAccountPayload): InstantCryptoCurrencyAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: InstantCryptoCurrencyAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): InstantCryptoCurrencyAccountPayload;
|
|
static deserializeBinaryFromReader(message: InstantCryptoCurrencyAccountPayload, reader: jspb.BinaryReader): InstantCryptoCurrencyAccountPayload;
|
|
}
|
|
|
|
export namespace InstantCryptoCurrencyAccountPayload {
|
|
export type AsObject = {
|
|
address: string,
|
|
}
|
|
}
|
|
|
|
export class FasterPaymentsAccountPayload extends jspb.Message {
|
|
getHolderName(): string;
|
|
setHolderName(value: string): FasterPaymentsAccountPayload;
|
|
|
|
getSortCode(): string;
|
|
setSortCode(value: string): FasterPaymentsAccountPayload;
|
|
|
|
getAccountNr(): string;
|
|
setAccountNr(value: string): FasterPaymentsAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): FasterPaymentsAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: FasterPaymentsAccountPayload): FasterPaymentsAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: FasterPaymentsAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): FasterPaymentsAccountPayload;
|
|
static deserializeBinaryFromReader(message: FasterPaymentsAccountPayload, reader: jspb.BinaryReader): FasterPaymentsAccountPayload;
|
|
}
|
|
|
|
export namespace FasterPaymentsAccountPayload {
|
|
export type AsObject = {
|
|
holderName: string,
|
|
sortCode: string,
|
|
accountNr: string,
|
|
}
|
|
}
|
|
|
|
export class InteracETransferAccountPayload extends jspb.Message {
|
|
getEmail(): string;
|
|
setEmail(value: string): InteracETransferAccountPayload;
|
|
|
|
getHolderName(): string;
|
|
setHolderName(value: string): InteracETransferAccountPayload;
|
|
|
|
getQuestion(): string;
|
|
setQuestion(value: string): InteracETransferAccountPayload;
|
|
|
|
getAnswer(): string;
|
|
setAnswer(value: string): InteracETransferAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): InteracETransferAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: InteracETransferAccountPayload): InteracETransferAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: InteracETransferAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): InteracETransferAccountPayload;
|
|
static deserializeBinaryFromReader(message: InteracETransferAccountPayload, reader: jspb.BinaryReader): InteracETransferAccountPayload;
|
|
}
|
|
|
|
export namespace InteracETransferAccountPayload {
|
|
export type AsObject = {
|
|
email: string,
|
|
holderName: string,
|
|
question: string,
|
|
answer: string,
|
|
}
|
|
}
|
|
|
|
export class OKPayAccountPayload extends jspb.Message {
|
|
getAccountNr(): string;
|
|
setAccountNr(value: string): OKPayAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): OKPayAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: OKPayAccountPayload): OKPayAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: OKPayAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): OKPayAccountPayload;
|
|
static deserializeBinaryFromReader(message: OKPayAccountPayload, reader: jspb.BinaryReader): OKPayAccountPayload;
|
|
}
|
|
|
|
export namespace OKPayAccountPayload {
|
|
export type AsObject = {
|
|
accountNr: string,
|
|
}
|
|
}
|
|
|
|
export class UpholdAccountPayload extends jspb.Message {
|
|
getAccountId(): string;
|
|
setAccountId(value: string): UpholdAccountPayload;
|
|
|
|
getAccountOwner(): string;
|
|
setAccountOwner(value: string): UpholdAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): UpholdAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: UpholdAccountPayload): UpholdAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: UpholdAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): UpholdAccountPayload;
|
|
static deserializeBinaryFromReader(message: UpholdAccountPayload, reader: jspb.BinaryReader): UpholdAccountPayload;
|
|
}
|
|
|
|
export namespace UpholdAccountPayload {
|
|
export type AsObject = {
|
|
accountId: string,
|
|
accountOwner: string,
|
|
}
|
|
}
|
|
|
|
export class CashAppAccountPayload extends jspb.Message {
|
|
getCashTag(): string;
|
|
setCashTag(value: string): CashAppAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): CashAppAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: CashAppAccountPayload): CashAppAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: CashAppAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): CashAppAccountPayload;
|
|
static deserializeBinaryFromReader(message: CashAppAccountPayload, reader: jspb.BinaryReader): CashAppAccountPayload;
|
|
}
|
|
|
|
export namespace CashAppAccountPayload {
|
|
export type AsObject = {
|
|
cashTag: string,
|
|
}
|
|
}
|
|
|
|
export class MoneyBeamAccountPayload extends jspb.Message {
|
|
getAccountId(): string;
|
|
setAccountId(value: string): MoneyBeamAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): MoneyBeamAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: MoneyBeamAccountPayload): MoneyBeamAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: MoneyBeamAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): MoneyBeamAccountPayload;
|
|
static deserializeBinaryFromReader(message: MoneyBeamAccountPayload, reader: jspb.BinaryReader): MoneyBeamAccountPayload;
|
|
}
|
|
|
|
export namespace MoneyBeamAccountPayload {
|
|
export type AsObject = {
|
|
accountId: string,
|
|
}
|
|
}
|
|
|
|
export class VenmoAccountPayload extends jspb.Message {
|
|
getVenmoUserName(): string;
|
|
setVenmoUserName(value: string): VenmoAccountPayload;
|
|
|
|
getHolderName(): string;
|
|
setHolderName(value: string): VenmoAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): VenmoAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: VenmoAccountPayload): VenmoAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: VenmoAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): VenmoAccountPayload;
|
|
static deserializeBinaryFromReader(message: VenmoAccountPayload, reader: jspb.BinaryReader): VenmoAccountPayload;
|
|
}
|
|
|
|
export namespace VenmoAccountPayload {
|
|
export type AsObject = {
|
|
venmoUserName: string,
|
|
holderName: string,
|
|
}
|
|
}
|
|
|
|
export class PopmoneyAccountPayload extends jspb.Message {
|
|
getAccountId(): string;
|
|
setAccountId(value: string): PopmoneyAccountPayload;
|
|
|
|
getHolderName(): string;
|
|
setHolderName(value: string): PopmoneyAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PopmoneyAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PopmoneyAccountPayload): PopmoneyAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: PopmoneyAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PopmoneyAccountPayload;
|
|
static deserializeBinaryFromReader(message: PopmoneyAccountPayload, reader: jspb.BinaryReader): PopmoneyAccountPayload;
|
|
}
|
|
|
|
export namespace PopmoneyAccountPayload {
|
|
export type AsObject = {
|
|
accountId: string,
|
|
holderName: string,
|
|
}
|
|
}
|
|
|
|
export class RevolutAccountPayload extends jspb.Message {
|
|
getAccountId(): string;
|
|
setAccountId(value: string): RevolutAccountPayload;
|
|
|
|
getUserName(): string;
|
|
setUserName(value: string): RevolutAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): RevolutAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: RevolutAccountPayload): RevolutAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: RevolutAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): RevolutAccountPayload;
|
|
static deserializeBinaryFromReader(message: RevolutAccountPayload, reader: jspb.BinaryReader): RevolutAccountPayload;
|
|
}
|
|
|
|
export namespace RevolutAccountPayload {
|
|
export type AsObject = {
|
|
accountId: string,
|
|
userName: string,
|
|
}
|
|
}
|
|
|
|
export class PerfectMoneyAccountPayload extends jspb.Message {
|
|
getAccountNr(): string;
|
|
setAccountNr(value: string): PerfectMoneyAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PerfectMoneyAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PerfectMoneyAccountPayload): PerfectMoneyAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: PerfectMoneyAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PerfectMoneyAccountPayload;
|
|
static deserializeBinaryFromReader(message: PerfectMoneyAccountPayload, reader: jspb.BinaryReader): PerfectMoneyAccountPayload;
|
|
}
|
|
|
|
export namespace PerfectMoneyAccountPayload {
|
|
export type AsObject = {
|
|
accountNr: string,
|
|
}
|
|
}
|
|
|
|
export class SwishAccountPayload extends jspb.Message {
|
|
getMobileNr(): string;
|
|
setMobileNr(value: string): SwishAccountPayload;
|
|
|
|
getHolderName(): string;
|
|
setHolderName(value: string): SwishAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): SwishAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: SwishAccountPayload): SwishAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: SwishAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): SwishAccountPayload;
|
|
static deserializeBinaryFromReader(message: SwishAccountPayload, reader: jspb.BinaryReader): SwishAccountPayload;
|
|
}
|
|
|
|
export namespace SwishAccountPayload {
|
|
export type AsObject = {
|
|
mobileNr: string,
|
|
holderName: string,
|
|
}
|
|
}
|
|
|
|
export class USPostalMoneyOrderAccountPayload extends jspb.Message {
|
|
getPostalAddress(): string;
|
|
setPostalAddress(value: string): USPostalMoneyOrderAccountPayload;
|
|
|
|
getHolderName(): string;
|
|
setHolderName(value: string): USPostalMoneyOrderAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): USPostalMoneyOrderAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: USPostalMoneyOrderAccountPayload): USPostalMoneyOrderAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: USPostalMoneyOrderAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): USPostalMoneyOrderAccountPayload;
|
|
static deserializeBinaryFromReader(message: USPostalMoneyOrderAccountPayload, reader: jspb.BinaryReader): USPostalMoneyOrderAccountPayload;
|
|
}
|
|
|
|
export namespace USPostalMoneyOrderAccountPayload {
|
|
export type AsObject = {
|
|
postalAddress: string,
|
|
holderName: string,
|
|
}
|
|
}
|
|
|
|
export class F2FAccountPayload extends jspb.Message {
|
|
getContact(): string;
|
|
setContact(value: string): F2FAccountPayload;
|
|
|
|
getCity(): string;
|
|
setCity(value: string): F2FAccountPayload;
|
|
|
|
getExtraInfo(): string;
|
|
setExtraInfo(value: string): F2FAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): F2FAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: F2FAccountPayload): F2FAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: F2FAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): F2FAccountPayload;
|
|
static deserializeBinaryFromReader(message: F2FAccountPayload, reader: jspb.BinaryReader): F2FAccountPayload;
|
|
}
|
|
|
|
export namespace F2FAccountPayload {
|
|
export type AsObject = {
|
|
contact: string,
|
|
city: string,
|
|
extraInfo: string,
|
|
}
|
|
}
|
|
|
|
export class IfscBasedAccountPayload extends jspb.Message {
|
|
getHolderName(): string;
|
|
setHolderName(value: string): IfscBasedAccountPayload;
|
|
|
|
getAccountNr(): string;
|
|
setAccountNr(value: string): IfscBasedAccountPayload;
|
|
|
|
getIfsc(): string;
|
|
setIfsc(value: string): IfscBasedAccountPayload;
|
|
|
|
getNeftAccountPayload(): NeftAccountPayload | undefined;
|
|
setNeftAccountPayload(value?: NeftAccountPayload): IfscBasedAccountPayload;
|
|
hasNeftAccountPayload(): boolean;
|
|
clearNeftAccountPayload(): IfscBasedAccountPayload;
|
|
|
|
getRtgsAccountPayload(): RtgsAccountPayload | undefined;
|
|
setRtgsAccountPayload(value?: RtgsAccountPayload): IfscBasedAccountPayload;
|
|
hasRtgsAccountPayload(): boolean;
|
|
clearRtgsAccountPayload(): IfscBasedAccountPayload;
|
|
|
|
getImpsAccountPayload(): ImpsAccountPayload | undefined;
|
|
setImpsAccountPayload(value?: ImpsAccountPayload): IfscBasedAccountPayload;
|
|
hasImpsAccountPayload(): boolean;
|
|
clearImpsAccountPayload(): IfscBasedAccountPayload;
|
|
|
|
getMessageCase(): IfscBasedAccountPayload.MessageCase;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): IfscBasedAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: IfscBasedAccountPayload): IfscBasedAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: IfscBasedAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): IfscBasedAccountPayload;
|
|
static deserializeBinaryFromReader(message: IfscBasedAccountPayload, reader: jspb.BinaryReader): IfscBasedAccountPayload;
|
|
}
|
|
|
|
export namespace IfscBasedAccountPayload {
|
|
export type AsObject = {
|
|
holderName: string,
|
|
accountNr: string,
|
|
ifsc: string,
|
|
neftAccountPayload?: NeftAccountPayload.AsObject,
|
|
rtgsAccountPayload?: RtgsAccountPayload.AsObject,
|
|
impsAccountPayload?: ImpsAccountPayload.AsObject,
|
|
}
|
|
|
|
export enum MessageCase {
|
|
MESSAGE_NOT_SET = 0,
|
|
NEFT_ACCOUNT_PAYLOAD = 4,
|
|
RTGS_ACCOUNT_PAYLOAD = 5,
|
|
IMPS_ACCOUNT_PAYLOAD = 6,
|
|
}
|
|
}
|
|
|
|
export class NeftAccountPayload extends jspb.Message {
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): NeftAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: NeftAccountPayload): NeftAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: NeftAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): NeftAccountPayload;
|
|
static deserializeBinaryFromReader(message: NeftAccountPayload, reader: jspb.BinaryReader): NeftAccountPayload;
|
|
}
|
|
|
|
export namespace NeftAccountPayload {
|
|
export type AsObject = {
|
|
}
|
|
}
|
|
|
|
export class RtgsAccountPayload extends jspb.Message {
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): RtgsAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: RtgsAccountPayload): RtgsAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: RtgsAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): RtgsAccountPayload;
|
|
static deserializeBinaryFromReader(message: RtgsAccountPayload, reader: jspb.BinaryReader): RtgsAccountPayload;
|
|
}
|
|
|
|
export namespace RtgsAccountPayload {
|
|
export type AsObject = {
|
|
}
|
|
}
|
|
|
|
export class ImpsAccountPayload extends jspb.Message {
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): ImpsAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: ImpsAccountPayload): ImpsAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: ImpsAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): ImpsAccountPayload;
|
|
static deserializeBinaryFromReader(message: ImpsAccountPayload, reader: jspb.BinaryReader): ImpsAccountPayload;
|
|
}
|
|
|
|
export namespace ImpsAccountPayload {
|
|
export type AsObject = {
|
|
}
|
|
}
|
|
|
|
export class UpiAccountPayload extends jspb.Message {
|
|
getVirtualPaymentAddress(): string;
|
|
setVirtualPaymentAddress(value: string): UpiAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): UpiAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: UpiAccountPayload): UpiAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: UpiAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): UpiAccountPayload;
|
|
static deserializeBinaryFromReader(message: UpiAccountPayload, reader: jspb.BinaryReader): UpiAccountPayload;
|
|
}
|
|
|
|
export namespace UpiAccountPayload {
|
|
export type AsObject = {
|
|
virtualPaymentAddress: string,
|
|
}
|
|
}
|
|
|
|
export class PaytmAccountPayload extends jspb.Message {
|
|
getEmailOrMobileNr(): string;
|
|
setEmailOrMobileNr(value: string): PaytmAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PaytmAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PaytmAccountPayload): PaytmAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: PaytmAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PaytmAccountPayload;
|
|
static deserializeBinaryFromReader(message: PaytmAccountPayload, reader: jspb.BinaryReader): PaytmAccountPayload;
|
|
}
|
|
|
|
export namespace PaytmAccountPayload {
|
|
export type AsObject = {
|
|
emailOrMobileNr: string,
|
|
}
|
|
}
|
|
|
|
export class CashByMailAccountPayload extends jspb.Message {
|
|
getPostalAddress(): string;
|
|
setPostalAddress(value: string): CashByMailAccountPayload;
|
|
|
|
getContact(): string;
|
|
setContact(value: string): CashByMailAccountPayload;
|
|
|
|
getExtraInfo(): string;
|
|
setExtraInfo(value: string): CashByMailAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): CashByMailAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: CashByMailAccountPayload): CashByMailAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: CashByMailAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): CashByMailAccountPayload;
|
|
static deserializeBinaryFromReader(message: CashByMailAccountPayload, reader: jspb.BinaryReader): CashByMailAccountPayload;
|
|
}
|
|
|
|
export namespace CashByMailAccountPayload {
|
|
export type AsObject = {
|
|
postalAddress: string,
|
|
contact: string,
|
|
extraInfo: string,
|
|
}
|
|
}
|
|
|
|
export class PromptPayAccountPayload extends jspb.Message {
|
|
getPromptPayId(): string;
|
|
setPromptPayId(value: string): PromptPayAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PromptPayAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PromptPayAccountPayload): PromptPayAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: PromptPayAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PromptPayAccountPayload;
|
|
static deserializeBinaryFromReader(message: PromptPayAccountPayload, reader: jspb.BinaryReader): PromptPayAccountPayload;
|
|
}
|
|
|
|
export namespace PromptPayAccountPayload {
|
|
export type AsObject = {
|
|
promptPayId: string,
|
|
}
|
|
}
|
|
|
|
export class AdvancedCashAccountPayload extends jspb.Message {
|
|
getAccountNr(): string;
|
|
setAccountNr(value: string): AdvancedCashAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): AdvancedCashAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: AdvancedCashAccountPayload): AdvancedCashAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: AdvancedCashAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): AdvancedCashAccountPayload;
|
|
static deserializeBinaryFromReader(message: AdvancedCashAccountPayload, reader: jspb.BinaryReader): AdvancedCashAccountPayload;
|
|
}
|
|
|
|
export namespace AdvancedCashAccountPayload {
|
|
export type AsObject = {
|
|
accountNr: string,
|
|
}
|
|
}
|
|
|
|
export class TransferwiseAccountPayload extends jspb.Message {
|
|
getEmail(): string;
|
|
setEmail(value: string): TransferwiseAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): TransferwiseAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: TransferwiseAccountPayload): TransferwiseAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: TransferwiseAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): TransferwiseAccountPayload;
|
|
static deserializeBinaryFromReader(message: TransferwiseAccountPayload, reader: jspb.BinaryReader): TransferwiseAccountPayload;
|
|
}
|
|
|
|
export namespace TransferwiseAccountPayload {
|
|
export type AsObject = {
|
|
email: string,
|
|
}
|
|
}
|
|
|
|
export class TransferwiseUsdAccountPayload extends jspb.Message {
|
|
getEmail(): string;
|
|
setEmail(value: string): TransferwiseUsdAccountPayload;
|
|
|
|
getHolderName(): string;
|
|
setHolderName(value: string): TransferwiseUsdAccountPayload;
|
|
|
|
getBeneficiaryAddress(): string;
|
|
setBeneficiaryAddress(value: string): TransferwiseUsdAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): TransferwiseUsdAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: TransferwiseUsdAccountPayload): TransferwiseUsdAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: TransferwiseUsdAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): TransferwiseUsdAccountPayload;
|
|
static deserializeBinaryFromReader(message: TransferwiseUsdAccountPayload, reader: jspb.BinaryReader): TransferwiseUsdAccountPayload;
|
|
}
|
|
|
|
export namespace TransferwiseUsdAccountPayload {
|
|
export type AsObject = {
|
|
email: string,
|
|
holderName: string,
|
|
beneficiaryAddress: string,
|
|
}
|
|
}
|
|
|
|
export class PayseraAccountPayload extends jspb.Message {
|
|
getEmail(): string;
|
|
setEmail(value: string): PayseraAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PayseraAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PayseraAccountPayload): PayseraAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: PayseraAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PayseraAccountPayload;
|
|
static deserializeBinaryFromReader(message: PayseraAccountPayload, reader: jspb.BinaryReader): PayseraAccountPayload;
|
|
}
|
|
|
|
export namespace PayseraAccountPayload {
|
|
export type AsObject = {
|
|
email: string,
|
|
}
|
|
}
|
|
|
|
export class PaxumAccountPayload extends jspb.Message {
|
|
getEmail(): string;
|
|
setEmail(value: string): PaxumAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PaxumAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PaxumAccountPayload): PaxumAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: PaxumAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PaxumAccountPayload;
|
|
static deserializeBinaryFromReader(message: PaxumAccountPayload, reader: jspb.BinaryReader): PaxumAccountPayload;
|
|
}
|
|
|
|
export namespace PaxumAccountPayload {
|
|
export type AsObject = {
|
|
email: string,
|
|
}
|
|
}
|
|
|
|
export class CapitualAccountPayload extends jspb.Message {
|
|
getAccountNr(): string;
|
|
setAccountNr(value: string): CapitualAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): CapitualAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: CapitualAccountPayload): CapitualAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: CapitualAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): CapitualAccountPayload;
|
|
static deserializeBinaryFromReader(message: CapitualAccountPayload, reader: jspb.BinaryReader): CapitualAccountPayload;
|
|
}
|
|
|
|
export namespace CapitualAccountPayload {
|
|
export type AsObject = {
|
|
accountNr: string,
|
|
}
|
|
}
|
|
|
|
export class CelPayAccountPayload extends jspb.Message {
|
|
getEmail(): string;
|
|
setEmail(value: string): CelPayAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): CelPayAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: CelPayAccountPayload): CelPayAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: CelPayAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): CelPayAccountPayload;
|
|
static deserializeBinaryFromReader(message: CelPayAccountPayload, reader: jspb.BinaryReader): CelPayAccountPayload;
|
|
}
|
|
|
|
export namespace CelPayAccountPayload {
|
|
export type AsObject = {
|
|
email: string,
|
|
}
|
|
}
|
|
|
|
export class NequiAccountPayload extends jspb.Message {
|
|
getMobileNr(): string;
|
|
setMobileNr(value: string): NequiAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): NequiAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: NequiAccountPayload): NequiAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: NequiAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): NequiAccountPayload;
|
|
static deserializeBinaryFromReader(message: NequiAccountPayload, reader: jspb.BinaryReader): NequiAccountPayload;
|
|
}
|
|
|
|
export namespace NequiAccountPayload {
|
|
export type AsObject = {
|
|
mobileNr: string,
|
|
}
|
|
}
|
|
|
|
export class BizumAccountPayload extends jspb.Message {
|
|
getMobileNr(): string;
|
|
setMobileNr(value: string): BizumAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): BizumAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: BizumAccountPayload): BizumAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: BizumAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): BizumAccountPayload;
|
|
static deserializeBinaryFromReader(message: BizumAccountPayload, reader: jspb.BinaryReader): BizumAccountPayload;
|
|
}
|
|
|
|
export namespace BizumAccountPayload {
|
|
export type AsObject = {
|
|
mobileNr: string,
|
|
}
|
|
}
|
|
|
|
export class PixAccountPayload extends jspb.Message {
|
|
getPixKey(): string;
|
|
setPixKey(value: string): PixAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PixAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PixAccountPayload): PixAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: PixAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PixAccountPayload;
|
|
static deserializeBinaryFromReader(message: PixAccountPayload, reader: jspb.BinaryReader): PixAccountPayload;
|
|
}
|
|
|
|
export namespace PixAccountPayload {
|
|
export type AsObject = {
|
|
pixKey: string,
|
|
}
|
|
}
|
|
|
|
export class MoneseAccountPayload extends jspb.Message {
|
|
getMobileNr(): string;
|
|
setMobileNr(value: string): MoneseAccountPayload;
|
|
|
|
getHolderName(): string;
|
|
setHolderName(value: string): MoneseAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): MoneseAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: MoneseAccountPayload): MoneseAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: MoneseAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): MoneseAccountPayload;
|
|
static deserializeBinaryFromReader(message: MoneseAccountPayload, reader: jspb.BinaryReader): MoneseAccountPayload;
|
|
}
|
|
|
|
export namespace MoneseAccountPayload {
|
|
export type AsObject = {
|
|
mobileNr: string,
|
|
holderName: string,
|
|
}
|
|
}
|
|
|
|
export class SatispayAccountPayload extends jspb.Message {
|
|
getMobileNr(): string;
|
|
setMobileNr(value: string): SatispayAccountPayload;
|
|
|
|
getHolderName(): string;
|
|
setHolderName(value: string): SatispayAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): SatispayAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: SatispayAccountPayload): SatispayAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: SatispayAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): SatispayAccountPayload;
|
|
static deserializeBinaryFromReader(message: SatispayAccountPayload, reader: jspb.BinaryReader): SatispayAccountPayload;
|
|
}
|
|
|
|
export namespace SatispayAccountPayload {
|
|
export type AsObject = {
|
|
mobileNr: string,
|
|
holderName: string,
|
|
}
|
|
}
|
|
|
|
export class StrikeAccountPayload extends jspb.Message {
|
|
getHolderName(): string;
|
|
setHolderName(value: string): StrikeAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): StrikeAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: StrikeAccountPayload): StrikeAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: StrikeAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): StrikeAccountPayload;
|
|
static deserializeBinaryFromReader(message: StrikeAccountPayload, reader: jspb.BinaryReader): StrikeAccountPayload;
|
|
}
|
|
|
|
export namespace StrikeAccountPayload {
|
|
export type AsObject = {
|
|
holderName: string,
|
|
}
|
|
}
|
|
|
|
export class TikkieAccountPayload extends jspb.Message {
|
|
getIban(): string;
|
|
setIban(value: string): TikkieAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): TikkieAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: TikkieAccountPayload): TikkieAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: TikkieAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): TikkieAccountPayload;
|
|
static deserializeBinaryFromReader(message: TikkieAccountPayload, reader: jspb.BinaryReader): TikkieAccountPayload;
|
|
}
|
|
|
|
export namespace TikkieAccountPayload {
|
|
export type AsObject = {
|
|
iban: string,
|
|
}
|
|
}
|
|
|
|
export class VerseAccountPayload extends jspb.Message {
|
|
getHolderName(): string;
|
|
setHolderName(value: string): VerseAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): VerseAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: VerseAccountPayload): VerseAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: VerseAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): VerseAccountPayload;
|
|
static deserializeBinaryFromReader(message: VerseAccountPayload, reader: jspb.BinaryReader): VerseAccountPayload;
|
|
}
|
|
|
|
export namespace VerseAccountPayload {
|
|
export type AsObject = {
|
|
holderName: string,
|
|
}
|
|
}
|
|
|
|
export class SwiftAccountPayload extends jspb.Message {
|
|
getBeneficiaryName(): string;
|
|
setBeneficiaryName(value: string): SwiftAccountPayload;
|
|
|
|
getBeneficiaryAccountNr(): string;
|
|
setBeneficiaryAccountNr(value: string): SwiftAccountPayload;
|
|
|
|
getBeneficiaryAddress(): string;
|
|
setBeneficiaryAddress(value: string): SwiftAccountPayload;
|
|
|
|
getBeneficiaryCity(): string;
|
|
setBeneficiaryCity(value: string): SwiftAccountPayload;
|
|
|
|
getBeneficiaryPhone(): string;
|
|
setBeneficiaryPhone(value: string): SwiftAccountPayload;
|
|
|
|
getSpecialInstructions(): string;
|
|
setSpecialInstructions(value: string): SwiftAccountPayload;
|
|
|
|
getBankSwiftCode(): string;
|
|
setBankSwiftCode(value: string): SwiftAccountPayload;
|
|
|
|
getBankCountryCode(): string;
|
|
setBankCountryCode(value: string): SwiftAccountPayload;
|
|
|
|
getBankName(): string;
|
|
setBankName(value: string): SwiftAccountPayload;
|
|
|
|
getBankBranch(): string;
|
|
setBankBranch(value: string): SwiftAccountPayload;
|
|
|
|
getBankAddress(): string;
|
|
setBankAddress(value: string): SwiftAccountPayload;
|
|
|
|
getIntermediarySwiftCode(): string;
|
|
setIntermediarySwiftCode(value: string): SwiftAccountPayload;
|
|
|
|
getIntermediaryCountryCode(): string;
|
|
setIntermediaryCountryCode(value: string): SwiftAccountPayload;
|
|
|
|
getIntermediaryName(): string;
|
|
setIntermediaryName(value: string): SwiftAccountPayload;
|
|
|
|
getIntermediaryBranch(): string;
|
|
setIntermediaryBranch(value: string): SwiftAccountPayload;
|
|
|
|
getIntermediaryAddress(): string;
|
|
setIntermediaryAddress(value: string): SwiftAccountPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): SwiftAccountPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: SwiftAccountPayload): SwiftAccountPayload.AsObject;
|
|
static serializeBinaryToWriter(message: SwiftAccountPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): SwiftAccountPayload;
|
|
static deserializeBinaryFromReader(message: SwiftAccountPayload, reader: jspb.BinaryReader): SwiftAccountPayload;
|
|
}
|
|
|
|
export namespace SwiftAccountPayload {
|
|
export type AsObject = {
|
|
beneficiaryName: string,
|
|
beneficiaryAccountNr: string,
|
|
beneficiaryAddress: string,
|
|
beneficiaryCity: string,
|
|
beneficiaryPhone: string,
|
|
specialInstructions: string,
|
|
bankSwiftCode: string,
|
|
bankCountryCode: string,
|
|
bankName: string,
|
|
bankBranch: string,
|
|
bankAddress: string,
|
|
intermediarySwiftCode: string,
|
|
intermediaryCountryCode: string,
|
|
intermediaryName: string,
|
|
intermediaryBranch: string,
|
|
intermediaryAddress: string,
|
|
}
|
|
}
|
|
|
|
export class PersistableEnvelope extends jspb.Message {
|
|
getSequenceNumberMap(): SequenceNumberMap | undefined;
|
|
setSequenceNumberMap(value?: SequenceNumberMap): PersistableEnvelope;
|
|
hasSequenceNumberMap(): boolean;
|
|
clearSequenceNumberMap(): PersistableEnvelope;
|
|
|
|
getPersistedEntryMap(): PersistedEntryMap | undefined;
|
|
setPersistedEntryMap(value?: PersistedEntryMap): PersistableEnvelope;
|
|
hasPersistedEntryMap(): boolean;
|
|
clearPersistedEntryMap(): PersistableEnvelope;
|
|
|
|
getPeerList(): PeerList | undefined;
|
|
setPeerList(value?: PeerList): PersistableEnvelope;
|
|
hasPeerList(): boolean;
|
|
clearPeerList(): PersistableEnvelope;
|
|
|
|
getAddressEntryList(): AddressEntryList | undefined;
|
|
setAddressEntryList(value?: AddressEntryList): PersistableEnvelope;
|
|
hasAddressEntryList(): boolean;
|
|
clearAddressEntryList(): PersistableEnvelope;
|
|
|
|
getNavigationPath(): NavigationPath | undefined;
|
|
setNavigationPath(value?: NavigationPath): PersistableEnvelope;
|
|
hasNavigationPath(): boolean;
|
|
clearNavigationPath(): PersistableEnvelope;
|
|
|
|
getTradableList(): TradableList | undefined;
|
|
setTradableList(value?: TradableList): PersistableEnvelope;
|
|
hasTradableList(): boolean;
|
|
clearTradableList(): PersistableEnvelope;
|
|
|
|
getArbitrationDisputeList(): ArbitrationDisputeList | undefined;
|
|
setArbitrationDisputeList(value?: ArbitrationDisputeList): PersistableEnvelope;
|
|
hasArbitrationDisputeList(): boolean;
|
|
clearArbitrationDisputeList(): PersistableEnvelope;
|
|
|
|
getPreferencesPayload(): PreferencesPayload | undefined;
|
|
setPreferencesPayload(value?: PreferencesPayload): PersistableEnvelope;
|
|
hasPreferencesPayload(): boolean;
|
|
clearPreferencesPayload(): PersistableEnvelope;
|
|
|
|
getUserPayload(): UserPayload | undefined;
|
|
setUserPayload(value?: UserPayload): PersistableEnvelope;
|
|
hasUserPayload(): boolean;
|
|
clearUserPayload(): PersistableEnvelope;
|
|
|
|
getPaymentAccountList(): PaymentAccountList | undefined;
|
|
setPaymentAccountList(value?: PaymentAccountList): PersistableEnvelope;
|
|
hasPaymentAccountList(): boolean;
|
|
clearPaymentAccountList(): PersistableEnvelope;
|
|
|
|
getAccountAgeWitnessStore(): AccountAgeWitnessStore | undefined;
|
|
setAccountAgeWitnessStore(value?: AccountAgeWitnessStore): PersistableEnvelope;
|
|
hasAccountAgeWitnessStore(): boolean;
|
|
clearAccountAgeWitnessStore(): PersistableEnvelope;
|
|
|
|
getTradeStatistics2Store(): TradeStatistics2Store | undefined;
|
|
setTradeStatistics2Store(value?: TradeStatistics2Store): PersistableEnvelope;
|
|
hasTradeStatistics2Store(): boolean;
|
|
clearTradeStatistics2Store(): PersistableEnvelope;
|
|
|
|
getSignedWitnessStore(): SignedWitnessStore | undefined;
|
|
setSignedWitnessStore(value?: SignedWitnessStore): PersistableEnvelope;
|
|
hasSignedWitnessStore(): boolean;
|
|
clearSignedWitnessStore(): PersistableEnvelope;
|
|
|
|
getMediationDisputeList(): MediationDisputeList | undefined;
|
|
setMediationDisputeList(value?: MediationDisputeList): PersistableEnvelope;
|
|
hasMediationDisputeList(): boolean;
|
|
clearMediationDisputeList(): PersistableEnvelope;
|
|
|
|
getRefundDisputeList(): RefundDisputeList | undefined;
|
|
setRefundDisputeList(value?: RefundDisputeList): PersistableEnvelope;
|
|
hasRefundDisputeList(): boolean;
|
|
clearRefundDisputeList(): PersistableEnvelope;
|
|
|
|
getTradeStatistics3Store(): TradeStatistics3Store | undefined;
|
|
setTradeStatistics3Store(value?: TradeStatistics3Store): PersistableEnvelope;
|
|
hasTradeStatistics3Store(): boolean;
|
|
clearTradeStatistics3Store(): PersistableEnvelope;
|
|
|
|
getMailboxMessageList(): MailboxMessageList | undefined;
|
|
setMailboxMessageList(value?: MailboxMessageList): PersistableEnvelope;
|
|
hasMailboxMessageList(): boolean;
|
|
clearMailboxMessageList(): PersistableEnvelope;
|
|
|
|
getIgnoredMailboxMap(): IgnoredMailboxMap | undefined;
|
|
setIgnoredMailboxMap(value?: IgnoredMailboxMap): PersistableEnvelope;
|
|
hasIgnoredMailboxMap(): boolean;
|
|
clearIgnoredMailboxMap(): PersistableEnvelope;
|
|
|
|
getRemovedPayloadsMap(): RemovedPayloadsMap | undefined;
|
|
setRemovedPayloadsMap(value?: RemovedPayloadsMap): PersistableEnvelope;
|
|
hasRemovedPayloadsMap(): boolean;
|
|
clearRemovedPayloadsMap(): PersistableEnvelope;
|
|
|
|
getXmrAddressEntryList(): XmrAddressEntryList | undefined;
|
|
setXmrAddressEntryList(value?: XmrAddressEntryList): PersistableEnvelope;
|
|
hasXmrAddressEntryList(): boolean;
|
|
clearXmrAddressEntryList(): PersistableEnvelope;
|
|
|
|
getSignedOfferList(): SignedOfferList | undefined;
|
|
setSignedOfferList(value?: SignedOfferList): PersistableEnvelope;
|
|
hasSignedOfferList(): boolean;
|
|
clearSignedOfferList(): PersistableEnvelope;
|
|
|
|
getEncryptedConnectionList(): EncryptedConnectionList | undefined;
|
|
setEncryptedConnectionList(value?: EncryptedConnectionList): PersistableEnvelope;
|
|
hasEncryptedConnectionList(): boolean;
|
|
clearEncryptedConnectionList(): PersistableEnvelope;
|
|
|
|
getMessageCase(): PersistableEnvelope.MessageCase;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PersistableEnvelope.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PersistableEnvelope): PersistableEnvelope.AsObject;
|
|
static serializeBinaryToWriter(message: PersistableEnvelope, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PersistableEnvelope;
|
|
static deserializeBinaryFromReader(message: PersistableEnvelope, reader: jspb.BinaryReader): PersistableEnvelope;
|
|
}
|
|
|
|
export namespace PersistableEnvelope {
|
|
export type AsObject = {
|
|
sequenceNumberMap?: SequenceNumberMap.AsObject,
|
|
persistedEntryMap?: PersistedEntryMap.AsObject,
|
|
peerList?: PeerList.AsObject,
|
|
addressEntryList?: AddressEntryList.AsObject,
|
|
navigationPath?: NavigationPath.AsObject,
|
|
tradableList?: TradableList.AsObject,
|
|
arbitrationDisputeList?: ArbitrationDisputeList.AsObject,
|
|
preferencesPayload?: PreferencesPayload.AsObject,
|
|
userPayload?: UserPayload.AsObject,
|
|
paymentAccountList?: PaymentAccountList.AsObject,
|
|
accountAgeWitnessStore?: AccountAgeWitnessStore.AsObject,
|
|
tradeStatistics2Store?: TradeStatistics2Store.AsObject,
|
|
signedWitnessStore?: SignedWitnessStore.AsObject,
|
|
mediationDisputeList?: MediationDisputeList.AsObject,
|
|
refundDisputeList?: RefundDisputeList.AsObject,
|
|
tradeStatistics3Store?: TradeStatistics3Store.AsObject,
|
|
mailboxMessageList?: MailboxMessageList.AsObject,
|
|
ignoredMailboxMap?: IgnoredMailboxMap.AsObject,
|
|
removedPayloadsMap?: RemovedPayloadsMap.AsObject,
|
|
xmrAddressEntryList?: XmrAddressEntryList.AsObject,
|
|
signedOfferList?: SignedOfferList.AsObject,
|
|
encryptedConnectionList?: EncryptedConnectionList.AsObject,
|
|
}
|
|
|
|
export enum MessageCase {
|
|
MESSAGE_NOT_SET = 0,
|
|
SEQUENCE_NUMBER_MAP = 1,
|
|
PERSISTED_ENTRY_MAP = 2,
|
|
PEER_LIST = 3,
|
|
ADDRESS_ENTRY_LIST = 4,
|
|
NAVIGATION_PATH = 5,
|
|
TRADABLE_LIST = 6,
|
|
ARBITRATION_DISPUTE_LIST = 8,
|
|
PREFERENCES_PAYLOAD = 9,
|
|
USER_PAYLOAD = 10,
|
|
PAYMENT_ACCOUNT_LIST = 11,
|
|
ACCOUNT_AGE_WITNESS_STORE = 12,
|
|
TRADE_STATISTICS2_STORE = 13,
|
|
SIGNED_WITNESS_STORE = 15,
|
|
MEDIATION_DISPUTE_LIST = 16,
|
|
REFUND_DISPUTE_LIST = 17,
|
|
TRADE_STATISTICS3_STORE = 18,
|
|
MAILBOX_MESSAGE_LIST = 19,
|
|
IGNORED_MAILBOX_MAP = 20,
|
|
REMOVED_PAYLOADS_MAP = 21,
|
|
XMR_ADDRESS_ENTRY_LIST = 1001,
|
|
SIGNED_OFFER_LIST = 1002,
|
|
ENCRYPTED_CONNECTION_LIST = 1003,
|
|
}
|
|
}
|
|
|
|
export class SequenceNumberMap extends jspb.Message {
|
|
getSequenceNumberEntriesList(): Array<SequenceNumberEntry>;
|
|
setSequenceNumberEntriesList(value: Array<SequenceNumberEntry>): SequenceNumberMap;
|
|
clearSequenceNumberEntriesList(): SequenceNumberMap;
|
|
addSequenceNumberEntries(value?: SequenceNumberEntry, index?: number): SequenceNumberEntry;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): SequenceNumberMap.AsObject;
|
|
static toObject(includeInstance: boolean, msg: SequenceNumberMap): SequenceNumberMap.AsObject;
|
|
static serializeBinaryToWriter(message: SequenceNumberMap, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): SequenceNumberMap;
|
|
static deserializeBinaryFromReader(message: SequenceNumberMap, reader: jspb.BinaryReader): SequenceNumberMap;
|
|
}
|
|
|
|
export namespace SequenceNumberMap {
|
|
export type AsObject = {
|
|
sequenceNumberEntriesList: Array<SequenceNumberEntry.AsObject>,
|
|
}
|
|
}
|
|
|
|
export class SequenceNumberEntry extends jspb.Message {
|
|
getBytes(): ByteArray | undefined;
|
|
setBytes(value?: ByteArray): SequenceNumberEntry;
|
|
hasBytes(): boolean;
|
|
clearBytes(): SequenceNumberEntry;
|
|
|
|
getMapValue(): MapValue | undefined;
|
|
setMapValue(value?: MapValue): SequenceNumberEntry;
|
|
hasMapValue(): boolean;
|
|
clearMapValue(): SequenceNumberEntry;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): SequenceNumberEntry.AsObject;
|
|
static toObject(includeInstance: boolean, msg: SequenceNumberEntry): SequenceNumberEntry.AsObject;
|
|
static serializeBinaryToWriter(message: SequenceNumberEntry, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): SequenceNumberEntry;
|
|
static deserializeBinaryFromReader(message: SequenceNumberEntry, reader: jspb.BinaryReader): SequenceNumberEntry;
|
|
}
|
|
|
|
export namespace SequenceNumberEntry {
|
|
export type AsObject = {
|
|
bytes?: ByteArray.AsObject,
|
|
mapValue?: MapValue.AsObject,
|
|
}
|
|
}
|
|
|
|
export class ByteArray extends jspb.Message {
|
|
getBytes(): Uint8Array | string;
|
|
getBytes_asU8(): Uint8Array;
|
|
getBytes_asB64(): string;
|
|
setBytes(value: Uint8Array | string): ByteArray;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): ByteArray.AsObject;
|
|
static toObject(includeInstance: boolean, msg: ByteArray): ByteArray.AsObject;
|
|
static serializeBinaryToWriter(message: ByteArray, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): ByteArray;
|
|
static deserializeBinaryFromReader(message: ByteArray, reader: jspb.BinaryReader): ByteArray;
|
|
}
|
|
|
|
export namespace ByteArray {
|
|
export type AsObject = {
|
|
bytes: Uint8Array | string,
|
|
}
|
|
}
|
|
|
|
export class MapValue extends jspb.Message {
|
|
getSequenceNr(): number;
|
|
setSequenceNr(value: number): MapValue;
|
|
|
|
getTimeStamp(): number;
|
|
setTimeStamp(value: number): MapValue;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): MapValue.AsObject;
|
|
static toObject(includeInstance: boolean, msg: MapValue): MapValue.AsObject;
|
|
static serializeBinaryToWriter(message: MapValue, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): MapValue;
|
|
static deserializeBinaryFromReader(message: MapValue, reader: jspb.BinaryReader): MapValue;
|
|
}
|
|
|
|
export namespace MapValue {
|
|
export type AsObject = {
|
|
sequenceNr: number,
|
|
timeStamp: number,
|
|
}
|
|
}
|
|
|
|
export class PersistedEntryMap extends jspb.Message {
|
|
getPersistedEntryMapMap(): jspb.Map<string, ProtectedStorageEntry>;
|
|
clearPersistedEntryMapMap(): PersistedEntryMap;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PersistedEntryMap.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PersistedEntryMap): PersistedEntryMap.AsObject;
|
|
static serializeBinaryToWriter(message: PersistedEntryMap, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PersistedEntryMap;
|
|
static deserializeBinaryFromReader(message: PersistedEntryMap, reader: jspb.BinaryReader): PersistedEntryMap;
|
|
}
|
|
|
|
export namespace PersistedEntryMap {
|
|
export type AsObject = {
|
|
persistedEntryMapMap: Array<[string, ProtectedStorageEntry.AsObject]>,
|
|
}
|
|
}
|
|
|
|
export class AccountAgeWitnessStore extends jspb.Message {
|
|
getItemsList(): Array<AccountAgeWitness>;
|
|
setItemsList(value: Array<AccountAgeWitness>): AccountAgeWitnessStore;
|
|
clearItemsList(): AccountAgeWitnessStore;
|
|
addItems(value?: AccountAgeWitness, index?: number): AccountAgeWitness;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): AccountAgeWitnessStore.AsObject;
|
|
static toObject(includeInstance: boolean, msg: AccountAgeWitnessStore): AccountAgeWitnessStore.AsObject;
|
|
static serializeBinaryToWriter(message: AccountAgeWitnessStore, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): AccountAgeWitnessStore;
|
|
static deserializeBinaryFromReader(message: AccountAgeWitnessStore, reader: jspb.BinaryReader): AccountAgeWitnessStore;
|
|
}
|
|
|
|
export namespace AccountAgeWitnessStore {
|
|
export type AsObject = {
|
|
itemsList: Array<AccountAgeWitness.AsObject>,
|
|
}
|
|
}
|
|
|
|
export class SignedWitnessStore extends jspb.Message {
|
|
getItemsList(): Array<SignedWitness>;
|
|
setItemsList(value: Array<SignedWitness>): SignedWitnessStore;
|
|
clearItemsList(): SignedWitnessStore;
|
|
addItems(value?: SignedWitness, index?: number): SignedWitness;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): SignedWitnessStore.AsObject;
|
|
static toObject(includeInstance: boolean, msg: SignedWitnessStore): SignedWitnessStore.AsObject;
|
|
static serializeBinaryToWriter(message: SignedWitnessStore, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): SignedWitnessStore;
|
|
static deserializeBinaryFromReader(message: SignedWitnessStore, reader: jspb.BinaryReader): SignedWitnessStore;
|
|
}
|
|
|
|
export namespace SignedWitnessStore {
|
|
export type AsObject = {
|
|
itemsList: Array<SignedWitness.AsObject>,
|
|
}
|
|
}
|
|
|
|
export class TradeStatistics2Store extends jspb.Message {
|
|
getItemsList(): Array<TradeStatistics2>;
|
|
setItemsList(value: Array<TradeStatistics2>): TradeStatistics2Store;
|
|
clearItemsList(): TradeStatistics2Store;
|
|
addItems(value?: TradeStatistics2, index?: number): TradeStatistics2;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): TradeStatistics2Store.AsObject;
|
|
static toObject(includeInstance: boolean, msg: TradeStatistics2Store): TradeStatistics2Store.AsObject;
|
|
static serializeBinaryToWriter(message: TradeStatistics2Store, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): TradeStatistics2Store;
|
|
static deserializeBinaryFromReader(message: TradeStatistics2Store, reader: jspb.BinaryReader): TradeStatistics2Store;
|
|
}
|
|
|
|
export namespace TradeStatistics2Store {
|
|
export type AsObject = {
|
|
itemsList: Array<TradeStatistics2.AsObject>,
|
|
}
|
|
}
|
|
|
|
export class TradeStatistics3Store extends jspb.Message {
|
|
getItemsList(): Array<TradeStatistics3>;
|
|
setItemsList(value: Array<TradeStatistics3>): TradeStatistics3Store;
|
|
clearItemsList(): TradeStatistics3Store;
|
|
addItems(value?: TradeStatistics3, index?: number): TradeStatistics3;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): TradeStatistics3Store.AsObject;
|
|
static toObject(includeInstance: boolean, msg: TradeStatistics3Store): TradeStatistics3Store.AsObject;
|
|
static serializeBinaryToWriter(message: TradeStatistics3Store, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): TradeStatistics3Store;
|
|
static deserializeBinaryFromReader(message: TradeStatistics3Store, reader: jspb.BinaryReader): TradeStatistics3Store;
|
|
}
|
|
|
|
export namespace TradeStatistics3Store {
|
|
export type AsObject = {
|
|
itemsList: Array<TradeStatistics3.AsObject>,
|
|
}
|
|
}
|
|
|
|
export class PeerList extends jspb.Message {
|
|
getPeerList(): Array<Peer>;
|
|
setPeerList(value: Array<Peer>): PeerList;
|
|
clearPeerList(): PeerList;
|
|
addPeer(value?: Peer, index?: number): Peer;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PeerList.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PeerList): PeerList.AsObject;
|
|
static serializeBinaryToWriter(message: PeerList, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PeerList;
|
|
static deserializeBinaryFromReader(message: PeerList, reader: jspb.BinaryReader): PeerList;
|
|
}
|
|
|
|
export namespace PeerList {
|
|
export type AsObject = {
|
|
peerList: Array<Peer.AsObject>,
|
|
}
|
|
}
|
|
|
|
export class AddressEntryList extends jspb.Message {
|
|
getAddressEntryList(): Array<AddressEntry>;
|
|
setAddressEntryList(value: Array<AddressEntry>): AddressEntryList;
|
|
clearAddressEntryList(): AddressEntryList;
|
|
addAddressEntry(value?: AddressEntry, index?: number): AddressEntry;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): AddressEntryList.AsObject;
|
|
static toObject(includeInstance: boolean, msg: AddressEntryList): AddressEntryList.AsObject;
|
|
static serializeBinaryToWriter(message: AddressEntryList, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): AddressEntryList;
|
|
static deserializeBinaryFromReader(message: AddressEntryList, reader: jspb.BinaryReader): AddressEntryList;
|
|
}
|
|
|
|
export namespace AddressEntryList {
|
|
export type AsObject = {
|
|
addressEntryList: Array<AddressEntry.AsObject>,
|
|
}
|
|
}
|
|
|
|
export class AddressEntry extends jspb.Message {
|
|
getOfferId(): string;
|
|
setOfferId(value: string): AddressEntry;
|
|
|
|
getContext(): AddressEntry.Context;
|
|
setContext(value: AddressEntry.Context): AddressEntry;
|
|
|
|
getPubKey(): Uint8Array | string;
|
|
getPubKey_asU8(): Uint8Array;
|
|
getPubKey_asB64(): string;
|
|
setPubKey(value: Uint8Array | string): AddressEntry;
|
|
|
|
getPubKeyHash(): Uint8Array | string;
|
|
getPubKeyHash_asU8(): Uint8Array;
|
|
getPubKeyHash_asB64(): string;
|
|
setPubKeyHash(value: Uint8Array | string): AddressEntry;
|
|
|
|
getCoinLockedInMultiSig(): number;
|
|
setCoinLockedInMultiSig(value: number): AddressEntry;
|
|
|
|
getSegwit(): boolean;
|
|
setSegwit(value: boolean): AddressEntry;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): AddressEntry.AsObject;
|
|
static toObject(includeInstance: boolean, msg: AddressEntry): AddressEntry.AsObject;
|
|
static serializeBinaryToWriter(message: AddressEntry, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): AddressEntry;
|
|
static deserializeBinaryFromReader(message: AddressEntry, reader: jspb.BinaryReader): AddressEntry;
|
|
}
|
|
|
|
export namespace AddressEntry {
|
|
export type AsObject = {
|
|
offerId: string,
|
|
context: AddressEntry.Context,
|
|
pubKey: Uint8Array | string,
|
|
pubKeyHash: Uint8Array | string,
|
|
coinLockedInMultiSig: number,
|
|
segwit: boolean,
|
|
}
|
|
|
|
export enum Context {
|
|
PB_ERROR = 0,
|
|
ARBITRATOR = 1,
|
|
AVAILABLE = 2,
|
|
OFFER_FUNDING = 3,
|
|
RESERVED_FOR_TRADE = 4,
|
|
MULTI_SIG = 5,
|
|
TRADE_PAYOUT = 6,
|
|
}
|
|
}
|
|
|
|
export class XmrAddressEntryList extends jspb.Message {
|
|
getXmrAddressEntryList(): Array<XmrAddressEntry>;
|
|
setXmrAddressEntryList(value: Array<XmrAddressEntry>): XmrAddressEntryList;
|
|
clearXmrAddressEntryList(): XmrAddressEntryList;
|
|
addXmrAddressEntry(value?: XmrAddressEntry, index?: number): XmrAddressEntry;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): XmrAddressEntryList.AsObject;
|
|
static toObject(includeInstance: boolean, msg: XmrAddressEntryList): XmrAddressEntryList.AsObject;
|
|
static serializeBinaryToWriter(message: XmrAddressEntryList, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): XmrAddressEntryList;
|
|
static deserializeBinaryFromReader(message: XmrAddressEntryList, reader: jspb.BinaryReader): XmrAddressEntryList;
|
|
}
|
|
|
|
export namespace XmrAddressEntryList {
|
|
export type AsObject = {
|
|
xmrAddressEntryList: Array<XmrAddressEntry.AsObject>,
|
|
}
|
|
}
|
|
|
|
export class XmrAddressEntry extends jspb.Message {
|
|
getSubaddressIndex(): number;
|
|
setSubaddressIndex(value: number): XmrAddressEntry;
|
|
|
|
getAddressString(): string;
|
|
setAddressString(value: string): XmrAddressEntry;
|
|
|
|
getOfferId(): string;
|
|
setOfferId(value: string): XmrAddressEntry;
|
|
|
|
getContext(): XmrAddressEntry.Context;
|
|
setContext(value: XmrAddressEntry.Context): XmrAddressEntry;
|
|
|
|
getCoinLockedInMultiSig(): number;
|
|
setCoinLockedInMultiSig(value: number): XmrAddressEntry;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): XmrAddressEntry.AsObject;
|
|
static toObject(includeInstance: boolean, msg: XmrAddressEntry): XmrAddressEntry.AsObject;
|
|
static serializeBinaryToWriter(message: XmrAddressEntry, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): XmrAddressEntry;
|
|
static deserializeBinaryFromReader(message: XmrAddressEntry, reader: jspb.BinaryReader): XmrAddressEntry;
|
|
}
|
|
|
|
export namespace XmrAddressEntry {
|
|
export type AsObject = {
|
|
subaddressIndex: number,
|
|
addressString: string,
|
|
offerId: string,
|
|
context: XmrAddressEntry.Context,
|
|
coinLockedInMultiSig: number,
|
|
}
|
|
|
|
export enum Context {
|
|
PB_ERROR = 0,
|
|
ARBITRATOR = 1,
|
|
AVAILABLE = 2,
|
|
OFFER_FUNDING = 3,
|
|
RESERVED_FOR_TRADE = 4,
|
|
MULTI_SIG = 5,
|
|
TRADE_PAYOUT = 6,
|
|
}
|
|
}
|
|
|
|
export class NavigationPath extends jspb.Message {
|
|
getPathList(): Array<string>;
|
|
setPathList(value: Array<string>): NavigationPath;
|
|
clearPathList(): NavigationPath;
|
|
addPath(value: string, index?: number): NavigationPath;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): NavigationPath.AsObject;
|
|
static toObject(includeInstance: boolean, msg: NavigationPath): NavigationPath.AsObject;
|
|
static serializeBinaryToWriter(message: NavigationPath, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): NavigationPath;
|
|
static deserializeBinaryFromReader(message: NavigationPath, reader: jspb.BinaryReader): NavigationPath;
|
|
}
|
|
|
|
export namespace NavigationPath {
|
|
export type AsObject = {
|
|
pathList: Array<string>,
|
|
}
|
|
}
|
|
|
|
export class PaymentAccountList extends jspb.Message {
|
|
getPaymentAccountList(): Array<PaymentAccount>;
|
|
setPaymentAccountList(value: Array<PaymentAccount>): PaymentAccountList;
|
|
clearPaymentAccountList(): PaymentAccountList;
|
|
addPaymentAccount(value?: PaymentAccount, index?: number): PaymentAccount;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PaymentAccountList.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PaymentAccountList): PaymentAccountList.AsObject;
|
|
static serializeBinaryToWriter(message: PaymentAccountList, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PaymentAccountList;
|
|
static deserializeBinaryFromReader(message: PaymentAccountList, reader: jspb.BinaryReader): PaymentAccountList;
|
|
}
|
|
|
|
export namespace PaymentAccountList {
|
|
export type AsObject = {
|
|
paymentAccountList: Array<PaymentAccount.AsObject>,
|
|
}
|
|
}
|
|
|
|
export class TradableList extends jspb.Message {
|
|
getTradableList(): Array<Tradable>;
|
|
setTradableList(value: Array<Tradable>): TradableList;
|
|
clearTradableList(): TradableList;
|
|
addTradable(value?: Tradable, index?: number): Tradable;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): TradableList.AsObject;
|
|
static toObject(includeInstance: boolean, msg: TradableList): TradableList.AsObject;
|
|
static serializeBinaryToWriter(message: TradableList, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): TradableList;
|
|
static deserializeBinaryFromReader(message: TradableList, reader: jspb.BinaryReader): TradableList;
|
|
}
|
|
|
|
export namespace TradableList {
|
|
export type AsObject = {
|
|
tradableList: Array<Tradable.AsObject>,
|
|
}
|
|
}
|
|
|
|
export class Offer extends jspb.Message {
|
|
getOfferPayload(): OfferPayload | undefined;
|
|
setOfferPayload(value?: OfferPayload): Offer;
|
|
hasOfferPayload(): boolean;
|
|
clearOfferPayload(): Offer;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): Offer.AsObject;
|
|
static toObject(includeInstance: boolean, msg: Offer): Offer.AsObject;
|
|
static serializeBinaryToWriter(message: Offer, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): Offer;
|
|
static deserializeBinaryFromReader(message: Offer, reader: jspb.BinaryReader): Offer;
|
|
}
|
|
|
|
export namespace Offer {
|
|
export type AsObject = {
|
|
offerPayload?: OfferPayload.AsObject,
|
|
}
|
|
|
|
export enum State {
|
|
PB_ERROR = 0,
|
|
UNKNOWN = 1,
|
|
OFFER_FEE_RESERVED = 2,
|
|
AVAILABLE = 3,
|
|
NOT_AVAILABLE = 4,
|
|
REMOVED = 5,
|
|
MAKER_OFFLINE = 6,
|
|
}
|
|
}
|
|
|
|
export class SignedOfferList extends jspb.Message {
|
|
getSignedOfferList(): Array<SignedOffer>;
|
|
setSignedOfferList(value: Array<SignedOffer>): SignedOfferList;
|
|
clearSignedOfferList(): SignedOfferList;
|
|
addSignedOffer(value?: SignedOffer, index?: number): SignedOffer;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): SignedOfferList.AsObject;
|
|
static toObject(includeInstance: boolean, msg: SignedOfferList): SignedOfferList.AsObject;
|
|
static serializeBinaryToWriter(message: SignedOfferList, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): SignedOfferList;
|
|
static deserializeBinaryFromReader(message: SignedOfferList, reader: jspb.BinaryReader): SignedOfferList;
|
|
}
|
|
|
|
export namespace SignedOfferList {
|
|
export type AsObject = {
|
|
signedOfferList: Array<SignedOffer.AsObject>,
|
|
}
|
|
}
|
|
|
|
export class SignedOffer extends jspb.Message {
|
|
getTimeStamp(): number;
|
|
setTimeStamp(value: number): SignedOffer;
|
|
|
|
getOfferId(): string;
|
|
setOfferId(value: string): SignedOffer;
|
|
|
|
getTradeAmount(): number;
|
|
setTradeAmount(value: number): SignedOffer;
|
|
|
|
getMakerTradeFee(): number;
|
|
setMakerTradeFee(value: number): SignedOffer;
|
|
|
|
getReserveTxHash(): string;
|
|
setReserveTxHash(value: string): SignedOffer;
|
|
|
|
getReserveTxHex(): string;
|
|
setReserveTxHex(value: string): SignedOffer;
|
|
|
|
getReserveTxKeyImagesList(): Array<string>;
|
|
setReserveTxKeyImagesList(value: Array<string>): SignedOffer;
|
|
clearReserveTxKeyImagesList(): SignedOffer;
|
|
addReserveTxKeyImages(value: string, index?: number): SignedOffer;
|
|
|
|
getReserveTxMinerFee(): number;
|
|
setReserveTxMinerFee(value: number): SignedOffer;
|
|
|
|
getArbitratorSignature(): string;
|
|
setArbitratorSignature(value: string): SignedOffer;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): SignedOffer.AsObject;
|
|
static toObject(includeInstance: boolean, msg: SignedOffer): SignedOffer.AsObject;
|
|
static serializeBinaryToWriter(message: SignedOffer, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): SignedOffer;
|
|
static deserializeBinaryFromReader(message: SignedOffer, reader: jspb.BinaryReader): SignedOffer;
|
|
}
|
|
|
|
export namespace SignedOffer {
|
|
export type AsObject = {
|
|
timeStamp: number,
|
|
offerId: string,
|
|
tradeAmount: number,
|
|
makerTradeFee: number,
|
|
reserveTxHash: string,
|
|
reserveTxHex: string,
|
|
reserveTxKeyImagesList: Array<string>,
|
|
reserveTxMinerFee: number,
|
|
arbitratorSignature: string,
|
|
}
|
|
}
|
|
|
|
export class OpenOffer extends jspb.Message {
|
|
getOffer(): Offer | undefined;
|
|
setOffer(value?: Offer): OpenOffer;
|
|
hasOffer(): boolean;
|
|
clearOffer(): OpenOffer;
|
|
|
|
getState(): OpenOffer.State;
|
|
setState(value: OpenOffer.State): OpenOffer;
|
|
|
|
getTriggerPrice(): number;
|
|
setTriggerPrice(value: number): OpenOffer;
|
|
|
|
getAutoSplit(): boolean;
|
|
setAutoSplit(value: boolean): OpenOffer;
|
|
|
|
getScheduledTxHashesList(): Array<string>;
|
|
setScheduledTxHashesList(value: Array<string>): OpenOffer;
|
|
clearScheduledTxHashesList(): OpenOffer;
|
|
addScheduledTxHashes(value: string, index?: number): OpenOffer;
|
|
|
|
getScheduledAmount(): string;
|
|
setScheduledAmount(value: string): OpenOffer;
|
|
|
|
getReserveTxHash(): string;
|
|
setReserveTxHash(value: string): OpenOffer;
|
|
|
|
getReserveTxHex(): string;
|
|
setReserveTxHex(value: string): OpenOffer;
|
|
|
|
getReserveTxKey(): string;
|
|
setReserveTxKey(value: string): OpenOffer;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): OpenOffer.AsObject;
|
|
static toObject(includeInstance: boolean, msg: OpenOffer): OpenOffer.AsObject;
|
|
static serializeBinaryToWriter(message: OpenOffer, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): OpenOffer;
|
|
static deserializeBinaryFromReader(message: OpenOffer, reader: jspb.BinaryReader): OpenOffer;
|
|
}
|
|
|
|
export namespace OpenOffer {
|
|
export type AsObject = {
|
|
offer?: Offer.AsObject,
|
|
state: OpenOffer.State,
|
|
triggerPrice: number,
|
|
autoSplit: boolean,
|
|
scheduledTxHashesList: Array<string>,
|
|
scheduledAmount: string,
|
|
reserveTxHash: string,
|
|
reserveTxHex: string,
|
|
reserveTxKey: string,
|
|
}
|
|
|
|
export enum State {
|
|
PB_ERROR = 0,
|
|
SCHEDULED = 1,
|
|
AVAILABLE = 2,
|
|
RESERVED = 3,
|
|
CLOSED = 4,
|
|
CANCELED = 5,
|
|
DEACTIVATED = 6,
|
|
}
|
|
}
|
|
|
|
export class Tradable extends jspb.Message {
|
|
getOpenOffer(): OpenOffer | undefined;
|
|
setOpenOffer(value?: OpenOffer): Tradable;
|
|
hasOpenOffer(): boolean;
|
|
clearOpenOffer(): Tradable;
|
|
|
|
getBuyerAsMakerTrade(): BuyerAsMakerTrade | undefined;
|
|
setBuyerAsMakerTrade(value?: BuyerAsMakerTrade): Tradable;
|
|
hasBuyerAsMakerTrade(): boolean;
|
|
clearBuyerAsMakerTrade(): Tradable;
|
|
|
|
getBuyerAsTakerTrade(): BuyerAsTakerTrade | undefined;
|
|
setBuyerAsTakerTrade(value?: BuyerAsTakerTrade): Tradable;
|
|
hasBuyerAsTakerTrade(): boolean;
|
|
clearBuyerAsTakerTrade(): Tradable;
|
|
|
|
getSellerAsMakerTrade(): SellerAsMakerTrade | undefined;
|
|
setSellerAsMakerTrade(value?: SellerAsMakerTrade): Tradable;
|
|
hasSellerAsMakerTrade(): boolean;
|
|
clearSellerAsMakerTrade(): Tradable;
|
|
|
|
getSellerAsTakerTrade(): SellerAsTakerTrade | undefined;
|
|
setSellerAsTakerTrade(value?: SellerAsTakerTrade): Tradable;
|
|
hasSellerAsTakerTrade(): boolean;
|
|
clearSellerAsTakerTrade(): Tradable;
|
|
|
|
getArbitratorTrade(): ArbitratorTrade | undefined;
|
|
setArbitratorTrade(value?: ArbitratorTrade): Tradable;
|
|
hasArbitratorTrade(): boolean;
|
|
clearArbitratorTrade(): Tradable;
|
|
|
|
getSignedOffer(): SignedOffer | undefined;
|
|
setSignedOffer(value?: SignedOffer): Tradable;
|
|
hasSignedOffer(): boolean;
|
|
clearSignedOffer(): Tradable;
|
|
|
|
getMessageCase(): Tradable.MessageCase;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): Tradable.AsObject;
|
|
static toObject(includeInstance: boolean, msg: Tradable): Tradable.AsObject;
|
|
static serializeBinaryToWriter(message: Tradable, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): Tradable;
|
|
static deserializeBinaryFromReader(message: Tradable, reader: jspb.BinaryReader): Tradable;
|
|
}
|
|
|
|
export namespace Tradable {
|
|
export type AsObject = {
|
|
openOffer?: OpenOffer.AsObject,
|
|
buyerAsMakerTrade?: BuyerAsMakerTrade.AsObject,
|
|
buyerAsTakerTrade?: BuyerAsTakerTrade.AsObject,
|
|
sellerAsMakerTrade?: SellerAsMakerTrade.AsObject,
|
|
sellerAsTakerTrade?: SellerAsTakerTrade.AsObject,
|
|
arbitratorTrade?: ArbitratorTrade.AsObject,
|
|
signedOffer?: SignedOffer.AsObject,
|
|
}
|
|
|
|
export enum MessageCase {
|
|
MESSAGE_NOT_SET = 0,
|
|
OPEN_OFFER = 1,
|
|
BUYER_AS_MAKER_TRADE = 2,
|
|
BUYER_AS_TAKER_TRADE = 3,
|
|
SELLER_AS_MAKER_TRADE = 4,
|
|
SELLER_AS_TAKER_TRADE = 5,
|
|
ARBITRATOR_TRADE = 6,
|
|
SIGNED_OFFER = 1001,
|
|
}
|
|
}
|
|
|
|
export class Trade extends jspb.Message {
|
|
getOffer(): Offer | undefined;
|
|
setOffer(value?: Offer): Trade;
|
|
hasOffer(): boolean;
|
|
clearOffer(): Trade;
|
|
|
|
getProcessModel(): ProcessModel | undefined;
|
|
setProcessModel(value?: ProcessModel): Trade;
|
|
hasProcessModel(): boolean;
|
|
clearProcessModel(): Trade;
|
|
|
|
getPayoutTxId(): string;
|
|
setPayoutTxId(value: string): Trade;
|
|
|
|
getPayoutTxHex(): string;
|
|
setPayoutTxHex(value: string): Trade;
|
|
|
|
getPayoutTxKey(): string;
|
|
setPayoutTxKey(value: string): Trade;
|
|
|
|
getAmountAsLong(): number;
|
|
setAmountAsLong(value: number): Trade;
|
|
|
|
getTakerFeeAsLong(): number;
|
|
setTakerFeeAsLong(value: number): Trade;
|
|
|
|
getTakeOfferDate(): number;
|
|
setTakeOfferDate(value: number): Trade;
|
|
|
|
getPrice(): number;
|
|
setPrice(value: number): Trade;
|
|
|
|
getState(): Trade.State;
|
|
setState(value: Trade.State): Trade;
|
|
|
|
getPayoutState(): Trade.PayoutState;
|
|
setPayoutState(value: Trade.PayoutState): Trade;
|
|
|
|
getDisputeState(): Trade.DisputeState;
|
|
setDisputeState(value: Trade.DisputeState): Trade;
|
|
|
|
getPeriodState(): Trade.TradePeriodState;
|
|
setPeriodState(value: Trade.TradePeriodState): Trade;
|
|
|
|
getContract(): Contract | undefined;
|
|
setContract(value?: Contract): Trade;
|
|
hasContract(): boolean;
|
|
clearContract(): Trade;
|
|
|
|
getContractAsJson(): string;
|
|
setContractAsJson(value: string): Trade;
|
|
|
|
getContractHash(): Uint8Array | string;
|
|
getContractHash_asU8(): Uint8Array;
|
|
getContractHash_asB64(): string;
|
|
setContractHash(value: Uint8Array | string): Trade;
|
|
|
|
getArbitratorNodeAddress(): NodeAddress | undefined;
|
|
setArbitratorNodeAddress(value?: NodeAddress): Trade;
|
|
hasArbitratorNodeAddress(): boolean;
|
|
clearArbitratorNodeAddress(): Trade;
|
|
|
|
getMediatorNodeAddress(): NodeAddress | undefined;
|
|
setMediatorNodeAddress(value?: NodeAddress): Trade;
|
|
hasMediatorNodeAddress(): boolean;
|
|
clearMediatorNodeAddress(): Trade;
|
|
|
|
getErrorMessage(): string;
|
|
setErrorMessage(value: string): Trade;
|
|
|
|
getCounterCurrencyTxId(): string;
|
|
setCounterCurrencyTxId(value: string): Trade;
|
|
|
|
getChatMessageList(): Array<ChatMessage>;
|
|
setChatMessageList(value: Array<ChatMessage>): Trade;
|
|
clearChatMessageList(): Trade;
|
|
addChatMessage(value?: ChatMessage, index?: number): ChatMessage;
|
|
|
|
getMediationResultState(): MediationResultState;
|
|
setMediationResultState(value: MediationResultState): Trade;
|
|
|
|
getLockTime(): number;
|
|
setLockTime(value: number): Trade;
|
|
|
|
getStartTime(): number;
|
|
setStartTime(value: number): Trade;
|
|
|
|
getRefundAgentNodeAddress(): NodeAddress | undefined;
|
|
setRefundAgentNodeAddress(value?: NodeAddress): Trade;
|
|
hasRefundAgentNodeAddress(): boolean;
|
|
clearRefundAgentNodeAddress(): Trade;
|
|
|
|
getRefundResultState(): RefundResultState;
|
|
setRefundResultState(value: RefundResultState): Trade;
|
|
|
|
getCounterCurrencyExtraData(): string;
|
|
setCounterCurrencyExtraData(value: string): Trade;
|
|
|
|
getAssetTxProofResult(): string;
|
|
setAssetTxProofResult(value: string): Trade;
|
|
|
|
getUid(): string;
|
|
setUid(value: string): Trade;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): Trade.AsObject;
|
|
static toObject(includeInstance: boolean, msg: Trade): Trade.AsObject;
|
|
static serializeBinaryToWriter(message: Trade, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): Trade;
|
|
static deserializeBinaryFromReader(message: Trade, reader: jspb.BinaryReader): Trade;
|
|
}
|
|
|
|
export namespace Trade {
|
|
export type AsObject = {
|
|
offer?: Offer.AsObject,
|
|
processModel?: ProcessModel.AsObject,
|
|
payoutTxId: string,
|
|
payoutTxHex: string,
|
|
payoutTxKey: string,
|
|
amountAsLong: number,
|
|
takerFeeAsLong: number,
|
|
takeOfferDate: number,
|
|
price: number,
|
|
state: Trade.State,
|
|
payoutState: Trade.PayoutState,
|
|
disputeState: Trade.DisputeState,
|
|
periodState: Trade.TradePeriodState,
|
|
contract?: Contract.AsObject,
|
|
contractAsJson: string,
|
|
contractHash: Uint8Array | string,
|
|
arbitratorNodeAddress?: NodeAddress.AsObject,
|
|
mediatorNodeAddress?: NodeAddress.AsObject,
|
|
errorMessage: string,
|
|
counterCurrencyTxId: string,
|
|
chatMessageList: Array<ChatMessage.AsObject>,
|
|
mediationResultState: MediationResultState,
|
|
lockTime: number,
|
|
startTime: number,
|
|
refundAgentNodeAddress?: NodeAddress.AsObject,
|
|
refundResultState: RefundResultState,
|
|
counterCurrencyExtraData: string,
|
|
assetTxProofResult: string,
|
|
uid: string,
|
|
}
|
|
|
|
export enum State {
|
|
PB_ERROR_STATE = 0,
|
|
PREPARATION = 1,
|
|
MULTISIG_PREPARED = 2,
|
|
MULTISIG_MADE = 3,
|
|
MULTISIG_EXCHANGED = 4,
|
|
MULTISIG_COMPLETED = 5,
|
|
CONTRACT_SIGNATURE_REQUESTED = 6,
|
|
CONTRACT_SIGNED = 7,
|
|
SENT_PUBLISH_DEPOSIT_TX_REQUEST = 8,
|
|
SEND_FAILED_PUBLISH_DEPOSIT_TX_REQUEST = 9,
|
|
SAW_ARRIVED_PUBLISH_DEPOSIT_TX_REQUEST = 10,
|
|
PUBLISH_DEPOSIT_TX_REQUEST_FAILED = 11,
|
|
ARBITRATOR_PUBLISHED_DEPOSIT_TXS = 12,
|
|
DEPOSIT_TXS_SEEN_IN_NETWORK = 13,
|
|
DEPOSIT_TXS_CONFIRMED_IN_BLOCKCHAIN = 14,
|
|
DEPOSIT_TXS_UNLOCKED_IN_BLOCKCHAIN = 15,
|
|
BUYER_CONFIRMED_IN_UI_PAYMENT_SENT = 16,
|
|
BUYER_SENT_PAYMENT_SENT_MSG = 17,
|
|
BUYER_SEND_FAILED_PAYMENT_SENT_MSG = 18,
|
|
BUYER_STORED_IN_MAILBOX_PAYMENT_SENT_MSG = 19,
|
|
BUYER_SAW_ARRIVED_PAYMENT_SENT_MSG = 20,
|
|
SELLER_RECEIVED_PAYMENT_SENT_MSG = 21,
|
|
SELLER_CONFIRMED_IN_UI_PAYMENT_RECEIPT = 22,
|
|
SELLER_SENT_PAYMENT_RECEIVED_MSG = 23,
|
|
SELLER_SEND_FAILED_PAYMENT_RECEIVED_MSG = 24,
|
|
SELLER_STORED_IN_MAILBOX_PAYMENT_RECEIVED_MSG = 25,
|
|
SELLER_SAW_ARRIVED_PAYMENT_RECEIVED_MSG = 26,
|
|
TRADE_COMPLETED = 27,
|
|
}
|
|
|
|
export enum Phase {
|
|
PB_ERROR_PHASE = 0,
|
|
INIT = 1,
|
|
DEPOSIT_REQUESTED = 2,
|
|
DEPOSITS_PUBLISHED = 3,
|
|
DEPOSITS_CONFIRMED = 4,
|
|
DEPOSITS_UNLOCKED = 5,
|
|
PAYMENT_SENT = 6,
|
|
PAYMENT_RECEIVED = 7,
|
|
COMPLETED = 8,
|
|
}
|
|
|
|
export enum PayoutState {
|
|
PAYOUT_UNPUBLISHED = 0,
|
|
PAYOUT_PUBLISHED = 1,
|
|
PAYOUT_CONFIRMED = 2,
|
|
PAYOUT_UNLOCKED = 3,
|
|
}
|
|
|
|
export enum DisputeState {
|
|
PB_ERROR_DISPUTE_STATE = 0,
|
|
NO_DISPUTE = 1,
|
|
DISPUTE_REQUESTED = 2,
|
|
DISPUTE_OPENED = 3,
|
|
ARBITRATOR_SENT_DISPUTE_CLOSED_MSG = 4,
|
|
ARBITRATOR_SEND_FAILED_DISPUTE_CLOSED_MSG = 5,
|
|
ARBITRATOR_STORED_IN_MAILBOX_DISPUTE_CLOSED_MSG = 6,
|
|
ARBITRATOR_SAW_ARRIVED_DISPUTE_CLOSED_MSG = 7,
|
|
DISPUTE_CLOSED = 8,
|
|
MEDIATION_REQUESTED = 9,
|
|
MEDIATION_STARTED_BY_PEER = 10,
|
|
MEDIATION_CLOSED = 11,
|
|
REFUND_REQUESTED = 12,
|
|
REFUND_REQUEST_STARTED_BY_PEER = 13,
|
|
REFUND_REQUEST_CLOSED = 14,
|
|
}
|
|
|
|
export enum TradePeriodState {
|
|
PB_ERROR_TRADE_PERIOD_STATE = 0,
|
|
FIRST_HALF = 1,
|
|
SECOND_HALF = 2,
|
|
TRADE_PERIOD_OVER = 3,
|
|
}
|
|
}
|
|
|
|
export class BuyerAsMakerTrade extends jspb.Message {
|
|
getTrade(): Trade | undefined;
|
|
setTrade(value?: Trade): BuyerAsMakerTrade;
|
|
hasTrade(): boolean;
|
|
clearTrade(): BuyerAsMakerTrade;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): BuyerAsMakerTrade.AsObject;
|
|
static toObject(includeInstance: boolean, msg: BuyerAsMakerTrade): BuyerAsMakerTrade.AsObject;
|
|
static serializeBinaryToWriter(message: BuyerAsMakerTrade, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): BuyerAsMakerTrade;
|
|
static deserializeBinaryFromReader(message: BuyerAsMakerTrade, reader: jspb.BinaryReader): BuyerAsMakerTrade;
|
|
}
|
|
|
|
export namespace BuyerAsMakerTrade {
|
|
export type AsObject = {
|
|
trade?: Trade.AsObject,
|
|
}
|
|
}
|
|
|
|
export class BuyerAsTakerTrade extends jspb.Message {
|
|
getTrade(): Trade | undefined;
|
|
setTrade(value?: Trade): BuyerAsTakerTrade;
|
|
hasTrade(): boolean;
|
|
clearTrade(): BuyerAsTakerTrade;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): BuyerAsTakerTrade.AsObject;
|
|
static toObject(includeInstance: boolean, msg: BuyerAsTakerTrade): BuyerAsTakerTrade.AsObject;
|
|
static serializeBinaryToWriter(message: BuyerAsTakerTrade, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): BuyerAsTakerTrade;
|
|
static deserializeBinaryFromReader(message: BuyerAsTakerTrade, reader: jspb.BinaryReader): BuyerAsTakerTrade;
|
|
}
|
|
|
|
export namespace BuyerAsTakerTrade {
|
|
export type AsObject = {
|
|
trade?: Trade.AsObject,
|
|
}
|
|
}
|
|
|
|
export class SellerAsMakerTrade extends jspb.Message {
|
|
getTrade(): Trade | undefined;
|
|
setTrade(value?: Trade): SellerAsMakerTrade;
|
|
hasTrade(): boolean;
|
|
clearTrade(): SellerAsMakerTrade;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): SellerAsMakerTrade.AsObject;
|
|
static toObject(includeInstance: boolean, msg: SellerAsMakerTrade): SellerAsMakerTrade.AsObject;
|
|
static serializeBinaryToWriter(message: SellerAsMakerTrade, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): SellerAsMakerTrade;
|
|
static deserializeBinaryFromReader(message: SellerAsMakerTrade, reader: jspb.BinaryReader): SellerAsMakerTrade;
|
|
}
|
|
|
|
export namespace SellerAsMakerTrade {
|
|
export type AsObject = {
|
|
trade?: Trade.AsObject,
|
|
}
|
|
}
|
|
|
|
export class SellerAsTakerTrade extends jspb.Message {
|
|
getTrade(): Trade | undefined;
|
|
setTrade(value?: Trade): SellerAsTakerTrade;
|
|
hasTrade(): boolean;
|
|
clearTrade(): SellerAsTakerTrade;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): SellerAsTakerTrade.AsObject;
|
|
static toObject(includeInstance: boolean, msg: SellerAsTakerTrade): SellerAsTakerTrade.AsObject;
|
|
static serializeBinaryToWriter(message: SellerAsTakerTrade, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): SellerAsTakerTrade;
|
|
static deserializeBinaryFromReader(message: SellerAsTakerTrade, reader: jspb.BinaryReader): SellerAsTakerTrade;
|
|
}
|
|
|
|
export namespace SellerAsTakerTrade {
|
|
export type AsObject = {
|
|
trade?: Trade.AsObject,
|
|
}
|
|
}
|
|
|
|
export class ArbitratorTrade extends jspb.Message {
|
|
getTrade(): Trade | undefined;
|
|
setTrade(value?: Trade): ArbitratorTrade;
|
|
hasTrade(): boolean;
|
|
clearTrade(): ArbitratorTrade;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): ArbitratorTrade.AsObject;
|
|
static toObject(includeInstance: boolean, msg: ArbitratorTrade): ArbitratorTrade.AsObject;
|
|
static serializeBinaryToWriter(message: ArbitratorTrade, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): ArbitratorTrade;
|
|
static deserializeBinaryFromReader(message: ArbitratorTrade, reader: jspb.BinaryReader): ArbitratorTrade;
|
|
}
|
|
|
|
export namespace ArbitratorTrade {
|
|
export type AsObject = {
|
|
trade?: Trade.AsObject,
|
|
}
|
|
}
|
|
|
|
export class ProcessModel extends jspb.Message {
|
|
getOfferId(): string;
|
|
setOfferId(value: string): ProcessModel;
|
|
|
|
getAccountId(): string;
|
|
setAccountId(value: string): ProcessModel;
|
|
|
|
getPubKeyRing(): PubKeyRing | undefined;
|
|
setPubKeyRing(value?: PubKeyRing): ProcessModel;
|
|
hasPubKeyRing(): boolean;
|
|
clearPubKeyRing(): ProcessModel;
|
|
|
|
getTakeOfferFeeTxId(): string;
|
|
setTakeOfferFeeTxId(value: string): ProcessModel;
|
|
|
|
getPayoutTxSignature(): Uint8Array | string;
|
|
getPayoutTxSignature_asU8(): Uint8Array;
|
|
getPayoutTxSignature_asB64(): string;
|
|
setPayoutTxSignature(value: Uint8Array | string): ProcessModel;
|
|
|
|
getRawTransactionInputsList(): Array<RawTransactionInput>;
|
|
setRawTransactionInputsList(value: Array<RawTransactionInput>): ProcessModel;
|
|
clearRawTransactionInputsList(): ProcessModel;
|
|
addRawTransactionInputs(value?: RawTransactionInput, index?: number): RawTransactionInput;
|
|
|
|
getChangeOutputValue(): number;
|
|
setChangeOutputValue(value: number): ProcessModel;
|
|
|
|
getChangeOutputAddress(): string;
|
|
setChangeOutputAddress(value: string): ProcessModel;
|
|
|
|
getUseSavingsWallet(): boolean;
|
|
setUseSavingsWallet(value: boolean): ProcessModel;
|
|
|
|
getFundsNeededForTradeAsLong(): number;
|
|
setFundsNeededForTradeAsLong(value: number): ProcessModel;
|
|
|
|
getMyMultiSigPubKey(): Uint8Array | string;
|
|
getMyMultiSigPubKey_asU8(): Uint8Array;
|
|
getMyMultiSigPubKey_asB64(): string;
|
|
setMyMultiSigPubKey(value: Uint8Array | string): ProcessModel;
|
|
|
|
getPaymentSentMessageState(): string;
|
|
setPaymentSentMessageState(value: string): ProcessModel;
|
|
|
|
getMediatedPayoutTxSignature(): Uint8Array | string;
|
|
getMediatedPayoutTxSignature_asU8(): Uint8Array;
|
|
getMediatedPayoutTxSignature_asB64(): string;
|
|
setMediatedPayoutTxSignature(value: Uint8Array | string): ProcessModel;
|
|
|
|
getBuyerPayoutAmountFromMediation(): number;
|
|
setBuyerPayoutAmountFromMediation(value: number): ProcessModel;
|
|
|
|
getSellerPayoutAmountFromMediation(): number;
|
|
setSellerPayoutAmountFromMediation(value: number): ProcessModel;
|
|
|
|
getDepositsConfirmedMessagesDelivered(): boolean;
|
|
setDepositsConfirmedMessagesDelivered(value: boolean): ProcessModel;
|
|
|
|
getMakerSignature(): string;
|
|
setMakerSignature(value: string): ProcessModel;
|
|
|
|
getMaker(): TradePeer | undefined;
|
|
setMaker(value?: TradePeer): ProcessModel;
|
|
hasMaker(): boolean;
|
|
clearMaker(): ProcessModel;
|
|
|
|
getTaker(): TradePeer | undefined;
|
|
setTaker(value?: TradePeer): ProcessModel;
|
|
hasTaker(): boolean;
|
|
clearTaker(): ProcessModel;
|
|
|
|
getArbitrator(): TradePeer | undefined;
|
|
setArbitrator(value?: TradePeer): ProcessModel;
|
|
hasArbitrator(): boolean;
|
|
clearArbitrator(): ProcessModel;
|
|
|
|
getTempTradePeerNodeAddress(): NodeAddress | undefined;
|
|
setTempTradePeerNodeAddress(value?: NodeAddress): ProcessModel;
|
|
hasTempTradePeerNodeAddress(): boolean;
|
|
clearTempTradePeerNodeAddress(): ProcessModel;
|
|
|
|
getMultisigAddress(): string;
|
|
setMultisigAddress(value: string): ProcessModel;
|
|
|
|
getPaymentSentMessage(): PaymentSentMessage | undefined;
|
|
setPaymentSentMessage(value?: PaymentSentMessage): ProcessModel;
|
|
hasPaymentSentMessage(): boolean;
|
|
clearPaymentSentMessage(): ProcessModel;
|
|
|
|
getPaymentReceivedMessage(): PaymentReceivedMessage | undefined;
|
|
setPaymentReceivedMessage(value?: PaymentReceivedMessage): ProcessModel;
|
|
hasPaymentReceivedMessage(): boolean;
|
|
clearPaymentReceivedMessage(): ProcessModel;
|
|
|
|
getDisputeClosedMessage(): DisputeClosedMessage | undefined;
|
|
setDisputeClosedMessage(value?: DisputeClosedMessage): ProcessModel;
|
|
hasDisputeClosedMessage(): boolean;
|
|
clearDisputeClosedMessage(): ProcessModel;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): ProcessModel.AsObject;
|
|
static toObject(includeInstance: boolean, msg: ProcessModel): ProcessModel.AsObject;
|
|
static serializeBinaryToWriter(message: ProcessModel, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): ProcessModel;
|
|
static deserializeBinaryFromReader(message: ProcessModel, reader: jspb.BinaryReader): ProcessModel;
|
|
}
|
|
|
|
export namespace ProcessModel {
|
|
export type AsObject = {
|
|
offerId: string,
|
|
accountId: string,
|
|
pubKeyRing?: PubKeyRing.AsObject,
|
|
takeOfferFeeTxId: string,
|
|
payoutTxSignature: Uint8Array | string,
|
|
rawTransactionInputsList: Array<RawTransactionInput.AsObject>,
|
|
changeOutputValue: number,
|
|
changeOutputAddress: string,
|
|
useSavingsWallet: boolean,
|
|
fundsNeededForTradeAsLong: number,
|
|
myMultiSigPubKey: Uint8Array | string,
|
|
paymentSentMessageState: string,
|
|
mediatedPayoutTxSignature: Uint8Array | string,
|
|
buyerPayoutAmountFromMediation: number,
|
|
sellerPayoutAmountFromMediation: number,
|
|
depositsConfirmedMessagesDelivered: boolean,
|
|
makerSignature: string,
|
|
maker?: TradePeer.AsObject,
|
|
taker?: TradePeer.AsObject,
|
|
arbitrator?: TradePeer.AsObject,
|
|
tempTradePeerNodeAddress?: NodeAddress.AsObject,
|
|
multisigAddress: string,
|
|
paymentSentMessage?: PaymentSentMessage.AsObject,
|
|
paymentReceivedMessage?: PaymentReceivedMessage.AsObject,
|
|
disputeClosedMessage?: DisputeClosedMessage.AsObject,
|
|
}
|
|
}
|
|
|
|
export class TradePeer extends jspb.Message {
|
|
getNodeAddress(): NodeAddress | undefined;
|
|
setNodeAddress(value?: NodeAddress): TradePeer;
|
|
hasNodeAddress(): boolean;
|
|
clearNodeAddress(): TradePeer;
|
|
|
|
getPubKeyRing(): PubKeyRing | undefined;
|
|
setPubKeyRing(value?: PubKeyRing): TradePeer;
|
|
hasPubKeyRing(): boolean;
|
|
clearPubKeyRing(): TradePeer;
|
|
|
|
getAccountId(): string;
|
|
setAccountId(value: string): TradePeer;
|
|
|
|
getPaymentAccountId(): string;
|
|
setPaymentAccountId(value: string): TradePeer;
|
|
|
|
getPaymentMethodId(): string;
|
|
setPaymentMethodId(value: string): TradePeer;
|
|
|
|
getPaymentAccountPayloadHash(): Uint8Array | string;
|
|
getPaymentAccountPayloadHash_asU8(): Uint8Array;
|
|
getPaymentAccountPayloadHash_asB64(): string;
|
|
setPaymentAccountPayloadHash(value: Uint8Array | string): TradePeer;
|
|
|
|
getEncryptedPaymentAccountPayload(): Uint8Array | string;
|
|
getEncryptedPaymentAccountPayload_asU8(): Uint8Array;
|
|
getEncryptedPaymentAccountPayload_asB64(): string;
|
|
setEncryptedPaymentAccountPayload(value: Uint8Array | string): TradePeer;
|
|
|
|
getPaymentAccountKey(): Uint8Array | string;
|
|
getPaymentAccountKey_asU8(): Uint8Array;
|
|
getPaymentAccountKey_asB64(): string;
|
|
setPaymentAccountKey(value: Uint8Array | string): TradePeer;
|
|
|
|
getPaymentAccountPayload(): PaymentAccountPayload | undefined;
|
|
setPaymentAccountPayload(value?: PaymentAccountPayload): TradePeer;
|
|
hasPaymentAccountPayload(): boolean;
|
|
clearPaymentAccountPayload(): TradePeer;
|
|
|
|
getPayoutAddressString(): string;
|
|
setPayoutAddressString(value: string): TradePeer;
|
|
|
|
getContractAsJson(): string;
|
|
setContractAsJson(value: string): TradePeer;
|
|
|
|
getContractSignature(): string;
|
|
setContractSignature(value: string): TradePeer;
|
|
|
|
getSignature(): Uint8Array | string;
|
|
getSignature_asU8(): Uint8Array;
|
|
getSignature_asB64(): string;
|
|
setSignature(value: Uint8Array | string): TradePeer;
|
|
|
|
getMultiSigPubKey(): Uint8Array | string;
|
|
getMultiSigPubKey_asU8(): Uint8Array;
|
|
getMultiSigPubKey_asB64(): string;
|
|
setMultiSigPubKey(value: Uint8Array | string): TradePeer;
|
|
|
|
getRawTransactionInputsList(): Array<RawTransactionInput>;
|
|
setRawTransactionInputsList(value: Array<RawTransactionInput>): TradePeer;
|
|
clearRawTransactionInputsList(): TradePeer;
|
|
addRawTransactionInputs(value?: RawTransactionInput, index?: number): RawTransactionInput;
|
|
|
|
getChangeOutputValue(): number;
|
|
setChangeOutputValue(value: number): TradePeer;
|
|
|
|
getChangeOutputAddress(): string;
|
|
setChangeOutputAddress(value: string): TradePeer;
|
|
|
|
getAccountAgeWitnessNonce(): Uint8Array | string;
|
|
getAccountAgeWitnessNonce_asU8(): Uint8Array;
|
|
getAccountAgeWitnessNonce_asB64(): string;
|
|
setAccountAgeWitnessNonce(value: Uint8Array | string): TradePeer;
|
|
|
|
getAccountAgeWitnessSignature(): Uint8Array | string;
|
|
getAccountAgeWitnessSignature_asU8(): Uint8Array;
|
|
getAccountAgeWitnessSignature_asB64(): string;
|
|
setAccountAgeWitnessSignature(value: Uint8Array | string): TradePeer;
|
|
|
|
getAccountAgeWitness(): AccountAgeWitness | undefined;
|
|
setAccountAgeWitness(value?: AccountAgeWitness): TradePeer;
|
|
hasAccountAgeWitness(): boolean;
|
|
clearAccountAgeWitness(): TradePeer;
|
|
|
|
getCurrentDate(): number;
|
|
setCurrentDate(value: number): TradePeer;
|
|
|
|
getMediatedPayoutTxSignature(): Uint8Array | string;
|
|
getMediatedPayoutTxSignature_asU8(): Uint8Array;
|
|
getMediatedPayoutTxSignature_asB64(): string;
|
|
setMediatedPayoutTxSignature(value: Uint8Array | string): TradePeer;
|
|
|
|
getReserveTxHash(): string;
|
|
setReserveTxHash(value: string): TradePeer;
|
|
|
|
getReserveTxHex(): string;
|
|
setReserveTxHex(value: string): TradePeer;
|
|
|
|
getReserveTxKey(): string;
|
|
setReserveTxKey(value: string): TradePeer;
|
|
|
|
getReserveTxKeyImagesList(): Array<string>;
|
|
setReserveTxKeyImagesList(value: Array<string>): TradePeer;
|
|
clearReserveTxKeyImagesList(): TradePeer;
|
|
addReserveTxKeyImages(value: string, index?: number): TradePeer;
|
|
|
|
getPreparedMultisigHex(): string;
|
|
setPreparedMultisigHex(value: string): TradePeer;
|
|
|
|
getMadeMultisigHex(): string;
|
|
setMadeMultisigHex(value: string): TradePeer;
|
|
|
|
getExchangedMultisigHex(): string;
|
|
setExchangedMultisigHex(value: string): TradePeer;
|
|
|
|
getDepositTxHash(): string;
|
|
setDepositTxHash(value: string): TradePeer;
|
|
|
|
getDepositTxHex(): string;
|
|
setDepositTxHex(value: string): TradePeer;
|
|
|
|
getDepositTxKey(): string;
|
|
setDepositTxKey(value: string): TradePeer;
|
|
|
|
getSecurityDeposit(): number;
|
|
setSecurityDeposit(value: number): TradePeer;
|
|
|
|
getUpdatedMultisigHex(): string;
|
|
setUpdatedMultisigHex(value: string): TradePeer;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): TradePeer.AsObject;
|
|
static toObject(includeInstance: boolean, msg: TradePeer): TradePeer.AsObject;
|
|
static serializeBinaryToWriter(message: TradePeer, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): TradePeer;
|
|
static deserializeBinaryFromReader(message: TradePeer, reader: jspb.BinaryReader): TradePeer;
|
|
}
|
|
|
|
export namespace TradePeer {
|
|
export type AsObject = {
|
|
nodeAddress?: NodeAddress.AsObject,
|
|
pubKeyRing?: PubKeyRing.AsObject,
|
|
accountId: string,
|
|
paymentAccountId: string,
|
|
paymentMethodId: string,
|
|
paymentAccountPayloadHash: Uint8Array | string,
|
|
encryptedPaymentAccountPayload: Uint8Array | string,
|
|
paymentAccountKey: Uint8Array | string,
|
|
paymentAccountPayload?: PaymentAccountPayload.AsObject,
|
|
payoutAddressString: string,
|
|
contractAsJson: string,
|
|
contractSignature: string,
|
|
signature: Uint8Array | string,
|
|
multiSigPubKey: Uint8Array | string,
|
|
rawTransactionInputsList: Array<RawTransactionInput.AsObject>,
|
|
changeOutputValue: number,
|
|
changeOutputAddress: string,
|
|
accountAgeWitnessNonce: Uint8Array | string,
|
|
accountAgeWitnessSignature: Uint8Array | string,
|
|
accountAgeWitness?: AccountAgeWitness.AsObject,
|
|
currentDate: number,
|
|
mediatedPayoutTxSignature: Uint8Array | string,
|
|
reserveTxHash: string,
|
|
reserveTxHex: string,
|
|
reserveTxKey: string,
|
|
reserveTxKeyImagesList: Array<string>,
|
|
preparedMultisigHex: string,
|
|
madeMultisigHex: string,
|
|
exchangedMultisigHex: string,
|
|
depositTxHash: string,
|
|
depositTxHex: string,
|
|
depositTxKey: string,
|
|
securityDeposit: number,
|
|
updatedMultisigHex: string,
|
|
}
|
|
}
|
|
|
|
export class EncryptedConnection extends jspb.Message {
|
|
getUrl(): string;
|
|
setUrl(value: string): EncryptedConnection;
|
|
|
|
getUsername(): string;
|
|
setUsername(value: string): EncryptedConnection;
|
|
|
|
getEncryptedPassword(): Uint8Array | string;
|
|
getEncryptedPassword_asU8(): Uint8Array;
|
|
getEncryptedPassword_asB64(): string;
|
|
setEncryptedPassword(value: Uint8Array | string): EncryptedConnection;
|
|
|
|
getEncryptionSalt(): Uint8Array | string;
|
|
getEncryptionSalt_asU8(): Uint8Array;
|
|
getEncryptionSalt_asB64(): string;
|
|
setEncryptionSalt(value: Uint8Array | string): EncryptedConnection;
|
|
|
|
getPriority(): number;
|
|
setPriority(value: number): EncryptedConnection;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): EncryptedConnection.AsObject;
|
|
static toObject(includeInstance: boolean, msg: EncryptedConnection): EncryptedConnection.AsObject;
|
|
static serializeBinaryToWriter(message: EncryptedConnection, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): EncryptedConnection;
|
|
static deserializeBinaryFromReader(message: EncryptedConnection, reader: jspb.BinaryReader): EncryptedConnection;
|
|
}
|
|
|
|
export namespace EncryptedConnection {
|
|
export type AsObject = {
|
|
url: string,
|
|
username: string,
|
|
encryptedPassword: Uint8Array | string,
|
|
encryptionSalt: Uint8Array | string,
|
|
priority: number,
|
|
}
|
|
}
|
|
|
|
export class EncryptedConnectionList extends jspb.Message {
|
|
getSalt(): Uint8Array | string;
|
|
getSalt_asU8(): Uint8Array;
|
|
getSalt_asB64(): string;
|
|
setSalt(value: Uint8Array | string): EncryptedConnectionList;
|
|
|
|
getItemsList(): Array<EncryptedConnection>;
|
|
setItemsList(value: Array<EncryptedConnection>): EncryptedConnectionList;
|
|
clearItemsList(): EncryptedConnectionList;
|
|
addItems(value?: EncryptedConnection, index?: number): EncryptedConnection;
|
|
|
|
getCurrentConnectionUrl(): string;
|
|
setCurrentConnectionUrl(value: string): EncryptedConnectionList;
|
|
|
|
getRefreshPeriod(): number;
|
|
setRefreshPeriod(value: number): EncryptedConnectionList;
|
|
|
|
getAutoSwitch(): boolean;
|
|
setAutoSwitch(value: boolean): EncryptedConnectionList;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): EncryptedConnectionList.AsObject;
|
|
static toObject(includeInstance: boolean, msg: EncryptedConnectionList): EncryptedConnectionList.AsObject;
|
|
static serializeBinaryToWriter(message: EncryptedConnectionList, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): EncryptedConnectionList;
|
|
static deserializeBinaryFromReader(message: EncryptedConnectionList, reader: jspb.BinaryReader): EncryptedConnectionList;
|
|
}
|
|
|
|
export namespace EncryptedConnectionList {
|
|
export type AsObject = {
|
|
salt: Uint8Array | string,
|
|
itemsList: Array<EncryptedConnection.AsObject>,
|
|
currentConnectionUrl: string,
|
|
refreshPeriod: number,
|
|
autoSwitch: boolean,
|
|
}
|
|
}
|
|
|
|
export class ArbitrationDisputeList extends jspb.Message {
|
|
getDisputeList(): Array<Dispute>;
|
|
setDisputeList(value: Array<Dispute>): ArbitrationDisputeList;
|
|
clearDisputeList(): ArbitrationDisputeList;
|
|
addDispute(value?: Dispute, index?: number): Dispute;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): ArbitrationDisputeList.AsObject;
|
|
static toObject(includeInstance: boolean, msg: ArbitrationDisputeList): ArbitrationDisputeList.AsObject;
|
|
static serializeBinaryToWriter(message: ArbitrationDisputeList, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): ArbitrationDisputeList;
|
|
static deserializeBinaryFromReader(message: ArbitrationDisputeList, reader: jspb.BinaryReader): ArbitrationDisputeList;
|
|
}
|
|
|
|
export namespace ArbitrationDisputeList {
|
|
export type AsObject = {
|
|
disputeList: Array<Dispute.AsObject>,
|
|
}
|
|
}
|
|
|
|
export class MediationDisputeList extends jspb.Message {
|
|
getDisputeList(): Array<Dispute>;
|
|
setDisputeList(value: Array<Dispute>): MediationDisputeList;
|
|
clearDisputeList(): MediationDisputeList;
|
|
addDispute(value?: Dispute, index?: number): Dispute;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): MediationDisputeList.AsObject;
|
|
static toObject(includeInstance: boolean, msg: MediationDisputeList): MediationDisputeList.AsObject;
|
|
static serializeBinaryToWriter(message: MediationDisputeList, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): MediationDisputeList;
|
|
static deserializeBinaryFromReader(message: MediationDisputeList, reader: jspb.BinaryReader): MediationDisputeList;
|
|
}
|
|
|
|
export namespace MediationDisputeList {
|
|
export type AsObject = {
|
|
disputeList: Array<Dispute.AsObject>,
|
|
}
|
|
}
|
|
|
|
export class RefundDisputeList extends jspb.Message {
|
|
getDisputeList(): Array<Dispute>;
|
|
setDisputeList(value: Array<Dispute>): RefundDisputeList;
|
|
clearDisputeList(): RefundDisputeList;
|
|
addDispute(value?: Dispute, index?: number): Dispute;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): RefundDisputeList.AsObject;
|
|
static toObject(includeInstance: boolean, msg: RefundDisputeList): RefundDisputeList.AsObject;
|
|
static serializeBinaryToWriter(message: RefundDisputeList, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): RefundDisputeList;
|
|
static deserializeBinaryFromReader(message: RefundDisputeList, reader: jspb.BinaryReader): RefundDisputeList;
|
|
}
|
|
|
|
export namespace RefundDisputeList {
|
|
export type AsObject = {
|
|
disputeList: Array<Dispute.AsObject>,
|
|
}
|
|
}
|
|
|
|
export class PreferencesPayload extends jspb.Message {
|
|
getUserLanguage(): string;
|
|
setUserLanguage(value: string): PreferencesPayload;
|
|
|
|
getUserCountry(): Country | undefined;
|
|
setUserCountry(value?: Country): PreferencesPayload;
|
|
hasUserCountry(): boolean;
|
|
clearUserCountry(): PreferencesPayload;
|
|
|
|
getFiatCurrenciesList(): Array<TradeCurrency>;
|
|
setFiatCurrenciesList(value: Array<TradeCurrency>): PreferencesPayload;
|
|
clearFiatCurrenciesList(): PreferencesPayload;
|
|
addFiatCurrencies(value?: TradeCurrency, index?: number): TradeCurrency;
|
|
|
|
getCryptoCurrenciesList(): Array<TradeCurrency>;
|
|
setCryptoCurrenciesList(value: Array<TradeCurrency>): PreferencesPayload;
|
|
clearCryptoCurrenciesList(): PreferencesPayload;
|
|
addCryptoCurrencies(value?: TradeCurrency, index?: number): TradeCurrency;
|
|
|
|
getBlockChainExplorerMainNet(): BlockChainExplorer | undefined;
|
|
setBlockChainExplorerMainNet(value?: BlockChainExplorer): PreferencesPayload;
|
|
hasBlockChainExplorerMainNet(): boolean;
|
|
clearBlockChainExplorerMainNet(): PreferencesPayload;
|
|
|
|
getBlockChainExplorerTestNet(): BlockChainExplorer | undefined;
|
|
setBlockChainExplorerTestNet(value?: BlockChainExplorer): PreferencesPayload;
|
|
hasBlockChainExplorerTestNet(): boolean;
|
|
clearBlockChainExplorerTestNet(): PreferencesPayload;
|
|
|
|
getBackupDirectory(): string;
|
|
setBackupDirectory(value: string): PreferencesPayload;
|
|
|
|
getAutoSelectArbitrators(): boolean;
|
|
setAutoSelectArbitrators(value: boolean): PreferencesPayload;
|
|
|
|
getDontShowAgainMapMap(): jspb.Map<string, boolean>;
|
|
clearDontShowAgainMapMap(): PreferencesPayload;
|
|
|
|
getTacAccepted(): boolean;
|
|
setTacAccepted(value: boolean): PreferencesPayload;
|
|
|
|
getUseTorForBitcoinJ(): boolean;
|
|
setUseTorForBitcoinJ(value: boolean): PreferencesPayload;
|
|
|
|
getShowOwnOffersInOfferBook(): boolean;
|
|
setShowOwnOffersInOfferBook(value: boolean): PreferencesPayload;
|
|
|
|
getPreferredTradeCurrency(): TradeCurrency | undefined;
|
|
setPreferredTradeCurrency(value?: TradeCurrency): PreferencesPayload;
|
|
hasPreferredTradeCurrency(): boolean;
|
|
clearPreferredTradeCurrency(): PreferencesPayload;
|
|
|
|
getWithdrawalTxFeeInVbytes(): number;
|
|
setWithdrawalTxFeeInVbytes(value: number): PreferencesPayload;
|
|
|
|
getUseCustomWithdrawalTxFee(): boolean;
|
|
setUseCustomWithdrawalTxFee(value: boolean): PreferencesPayload;
|
|
|
|
getMaxPriceDistanceInPercent(): number;
|
|
setMaxPriceDistanceInPercent(value: number): PreferencesPayload;
|
|
|
|
getOfferBookChartScreenCurrencyCode(): string;
|
|
setOfferBookChartScreenCurrencyCode(value: string): PreferencesPayload;
|
|
|
|
getTradeChartsScreenCurrencyCode(): string;
|
|
setTradeChartsScreenCurrencyCode(value: string): PreferencesPayload;
|
|
|
|
getBuyScreenCurrencyCode(): string;
|
|
setBuyScreenCurrencyCode(value: string): PreferencesPayload;
|
|
|
|
getSellScreenCurrencyCode(): string;
|
|
setSellScreenCurrencyCode(value: string): PreferencesPayload;
|
|
|
|
getTradeStatisticsTickUnitIndex(): number;
|
|
setTradeStatisticsTickUnitIndex(value: number): PreferencesPayload;
|
|
|
|
getResyncSpvRequested(): boolean;
|
|
setResyncSpvRequested(value: boolean): PreferencesPayload;
|
|
|
|
getSortMarketCurrenciesNumerically(): boolean;
|
|
setSortMarketCurrenciesNumerically(value: boolean): PreferencesPayload;
|
|
|
|
getUsePercentageBasedPrice(): boolean;
|
|
setUsePercentageBasedPrice(value: boolean): PreferencesPayload;
|
|
|
|
getPeerTagMapMap(): jspb.Map<string, string>;
|
|
clearPeerTagMapMap(): PreferencesPayload;
|
|
|
|
getBitcoinNodes(): string;
|
|
setBitcoinNodes(value: string): PreferencesPayload;
|
|
|
|
getIgnoreTradersListList(): Array<string>;
|
|
setIgnoreTradersListList(value: Array<string>): PreferencesPayload;
|
|
clearIgnoreTradersListList(): PreferencesPayload;
|
|
addIgnoreTradersList(value: string, index?: number): PreferencesPayload;
|
|
|
|
getDirectoryChooserPath(): string;
|
|
setDirectoryChooserPath(value: string): PreferencesPayload;
|
|
|
|
getBuyerSecurityDepositAsLong(): number;
|
|
setBuyerSecurityDepositAsLong(value: number): PreferencesPayload;
|
|
|
|
getUseAnimations(): boolean;
|
|
setUseAnimations(value: boolean): PreferencesPayload;
|
|
|
|
getSelectedpaymentAccountForCreateoffer(): PaymentAccount | undefined;
|
|
setSelectedpaymentAccountForCreateoffer(value?: PaymentAccount): PreferencesPayload;
|
|
hasSelectedpaymentAccountForCreateoffer(): boolean;
|
|
clearSelectedpaymentAccountForCreateoffer(): PreferencesPayload;
|
|
|
|
getBridgeAddressesList(): Array<string>;
|
|
setBridgeAddressesList(value: Array<string>): PreferencesPayload;
|
|
clearBridgeAddressesList(): PreferencesPayload;
|
|
addBridgeAddresses(value: string, index?: number): PreferencesPayload;
|
|
|
|
getBridgeOptionOrdinal(): number;
|
|
setBridgeOptionOrdinal(value: number): PreferencesPayload;
|
|
|
|
getTorTransportOrdinal(): number;
|
|
setTorTransportOrdinal(value: number): PreferencesPayload;
|
|
|
|
getCustomBridges(): string;
|
|
setCustomBridges(value: string): PreferencesPayload;
|
|
|
|
getBitcoinNodesOptionOrdinal(): number;
|
|
setBitcoinNodesOptionOrdinal(value: number): PreferencesPayload;
|
|
|
|
getReferralId(): string;
|
|
setReferralId(value: string): PreferencesPayload;
|
|
|
|
getPhoneKeyAndToken(): string;
|
|
setPhoneKeyAndToken(value: string): PreferencesPayload;
|
|
|
|
getUseSoundForMobileNotifications(): boolean;
|
|
setUseSoundForMobileNotifications(value: boolean): PreferencesPayload;
|
|
|
|
getUseTradeNotifications(): boolean;
|
|
setUseTradeNotifications(value: boolean): PreferencesPayload;
|
|
|
|
getUseMarketNotifications(): boolean;
|
|
setUseMarketNotifications(value: boolean): PreferencesPayload;
|
|
|
|
getUsePriceNotifications(): boolean;
|
|
setUsePriceNotifications(value: boolean): PreferencesPayload;
|
|
|
|
getUseStandbyMode(): boolean;
|
|
setUseStandbyMode(value: boolean): PreferencesPayload;
|
|
|
|
getRpcUser(): string;
|
|
setRpcUser(value: string): PreferencesPayload;
|
|
|
|
getRpcPw(): string;
|
|
setRpcPw(value: string): PreferencesPayload;
|
|
|
|
getTakeOfferSelectedPaymentAccountId(): string;
|
|
setTakeOfferSelectedPaymentAccountId(value: string): PreferencesPayload;
|
|
|
|
getBuyerSecurityDepositAsPercent(): number;
|
|
setBuyerSecurityDepositAsPercent(value: number): PreferencesPayload;
|
|
|
|
getIgnoreDustThreshold(): number;
|
|
setIgnoreDustThreshold(value: number): PreferencesPayload;
|
|
|
|
getBuyerSecurityDepositAsPercentForCrypto(): number;
|
|
setBuyerSecurityDepositAsPercentForCrypto(value: number): PreferencesPayload;
|
|
|
|
getBlockNotifyPort(): number;
|
|
setBlockNotifyPort(value: number): PreferencesPayload;
|
|
|
|
getCssTheme(): number;
|
|
setCssTheme(value: number): PreferencesPayload;
|
|
|
|
getTacAcceptedV120(): boolean;
|
|
setTacAcceptedV120(value: boolean): PreferencesPayload;
|
|
|
|
getAutoConfirmSettingsList(): Array<AutoConfirmSettings>;
|
|
setAutoConfirmSettingsList(value: Array<AutoConfirmSettings>): PreferencesPayload;
|
|
clearAutoConfirmSettingsList(): PreferencesPayload;
|
|
addAutoConfirmSettings(value?: AutoConfirmSettings, index?: number): AutoConfirmSettings;
|
|
|
|
getBsqAverageTrimThreshold(): number;
|
|
setBsqAverageTrimThreshold(value: number): PreferencesPayload;
|
|
|
|
getHideNonAccountPaymentMethods(): boolean;
|
|
setHideNonAccountPaymentMethods(value: boolean): PreferencesPayload;
|
|
|
|
getShowOffersMatchingMyAccounts(): boolean;
|
|
setShowOffersMatchingMyAccounts(value: boolean): PreferencesPayload;
|
|
|
|
getDenyApiTaker(): boolean;
|
|
setDenyApiTaker(value: boolean): PreferencesPayload;
|
|
|
|
getNotifyOnPreRelease(): boolean;
|
|
setNotifyOnPreRelease(value: boolean): PreferencesPayload;
|
|
|
|
getMoneroNodeSettings(): MoneroNodeSettings | undefined;
|
|
setMoneroNodeSettings(value?: MoneroNodeSettings): PreferencesPayload;
|
|
hasMoneroNodeSettings(): boolean;
|
|
clearMoneroNodeSettings(): PreferencesPayload;
|
|
|
|
getClearDataAfterDays(): number;
|
|
setClearDataAfterDays(value: number): PreferencesPayload;
|
|
|
|
getBuyScreenCryptoCurrencyCode(): string;
|
|
setBuyScreenCryptoCurrencyCode(value: string): PreferencesPayload;
|
|
|
|
getSellScreenCryptoCurrencyCode(): string;
|
|
setSellScreenCryptoCurrencyCode(value: string): PreferencesPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PreferencesPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PreferencesPayload): PreferencesPayload.AsObject;
|
|
static serializeBinaryToWriter(message: PreferencesPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PreferencesPayload;
|
|
static deserializeBinaryFromReader(message: PreferencesPayload, reader: jspb.BinaryReader): PreferencesPayload;
|
|
}
|
|
|
|
export namespace PreferencesPayload {
|
|
export type AsObject = {
|
|
userLanguage: string,
|
|
userCountry?: Country.AsObject,
|
|
fiatCurrenciesList: Array<TradeCurrency.AsObject>,
|
|
cryptoCurrenciesList: Array<TradeCurrency.AsObject>,
|
|
blockChainExplorerMainNet?: BlockChainExplorer.AsObject,
|
|
blockChainExplorerTestNet?: BlockChainExplorer.AsObject,
|
|
backupDirectory: string,
|
|
autoSelectArbitrators: boolean,
|
|
dontShowAgainMapMap: Array<[string, boolean]>,
|
|
tacAccepted: boolean,
|
|
useTorForBitcoinJ: boolean,
|
|
showOwnOffersInOfferBook: boolean,
|
|
preferredTradeCurrency?: TradeCurrency.AsObject,
|
|
withdrawalTxFeeInVbytes: number,
|
|
useCustomWithdrawalTxFee: boolean,
|
|
maxPriceDistanceInPercent: number,
|
|
offerBookChartScreenCurrencyCode: string,
|
|
tradeChartsScreenCurrencyCode: string,
|
|
buyScreenCurrencyCode: string,
|
|
sellScreenCurrencyCode: string,
|
|
tradeStatisticsTickUnitIndex: number,
|
|
resyncSpvRequested: boolean,
|
|
sortMarketCurrenciesNumerically: boolean,
|
|
usePercentageBasedPrice: boolean,
|
|
peerTagMapMap: Array<[string, string]>,
|
|
bitcoinNodes: string,
|
|
ignoreTradersListList: Array<string>,
|
|
directoryChooserPath: string,
|
|
buyerSecurityDepositAsLong: number,
|
|
useAnimations: boolean,
|
|
selectedpaymentAccountForCreateoffer?: PaymentAccount.AsObject,
|
|
bridgeAddressesList: Array<string>,
|
|
bridgeOptionOrdinal: number,
|
|
torTransportOrdinal: number,
|
|
customBridges: string,
|
|
bitcoinNodesOptionOrdinal: number,
|
|
referralId: string,
|
|
phoneKeyAndToken: string,
|
|
useSoundForMobileNotifications: boolean,
|
|
useTradeNotifications: boolean,
|
|
useMarketNotifications: boolean,
|
|
usePriceNotifications: boolean,
|
|
useStandbyMode: boolean,
|
|
rpcUser: string,
|
|
rpcPw: string,
|
|
takeOfferSelectedPaymentAccountId: string,
|
|
buyerSecurityDepositAsPercent: number,
|
|
ignoreDustThreshold: number,
|
|
buyerSecurityDepositAsPercentForCrypto: number,
|
|
blockNotifyPort: number,
|
|
cssTheme: number,
|
|
tacAcceptedV120: boolean,
|
|
autoConfirmSettingsList: Array<AutoConfirmSettings.AsObject>,
|
|
bsqAverageTrimThreshold: number,
|
|
hideNonAccountPaymentMethods: boolean,
|
|
showOffersMatchingMyAccounts: boolean,
|
|
denyApiTaker: boolean,
|
|
notifyOnPreRelease: boolean,
|
|
moneroNodeSettings?: MoneroNodeSettings.AsObject,
|
|
clearDataAfterDays: number,
|
|
buyScreenCryptoCurrencyCode: string,
|
|
sellScreenCryptoCurrencyCode: string,
|
|
}
|
|
}
|
|
|
|
export class AutoConfirmSettings extends jspb.Message {
|
|
getEnabled(): boolean;
|
|
setEnabled(value: boolean): AutoConfirmSettings;
|
|
|
|
getRequiredConfirmations(): number;
|
|
setRequiredConfirmations(value: number): AutoConfirmSettings;
|
|
|
|
getTradeLimit(): number;
|
|
setTradeLimit(value: number): AutoConfirmSettings;
|
|
|
|
getServiceAddressesList(): Array<string>;
|
|
setServiceAddressesList(value: Array<string>): AutoConfirmSettings;
|
|
clearServiceAddressesList(): AutoConfirmSettings;
|
|
addServiceAddresses(value: string, index?: number): AutoConfirmSettings;
|
|
|
|
getCurrencyCode(): string;
|
|
setCurrencyCode(value: string): AutoConfirmSettings;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): AutoConfirmSettings.AsObject;
|
|
static toObject(includeInstance: boolean, msg: AutoConfirmSettings): AutoConfirmSettings.AsObject;
|
|
static serializeBinaryToWriter(message: AutoConfirmSettings, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): AutoConfirmSettings;
|
|
static deserializeBinaryFromReader(message: AutoConfirmSettings, reader: jspb.BinaryReader): AutoConfirmSettings;
|
|
}
|
|
|
|
export namespace AutoConfirmSettings {
|
|
export type AsObject = {
|
|
enabled: boolean,
|
|
requiredConfirmations: number,
|
|
tradeLimit: number,
|
|
serviceAddressesList: Array<string>,
|
|
currencyCode: string,
|
|
}
|
|
}
|
|
|
|
export class MoneroNodeSettings extends jspb.Message {
|
|
getBlockchainPath(): string;
|
|
setBlockchainPath(value: string): MoneroNodeSettings;
|
|
|
|
getBootstrapUrl(): string;
|
|
setBootstrapUrl(value: string): MoneroNodeSettings;
|
|
|
|
getStartupFlagsList(): Array<string>;
|
|
setStartupFlagsList(value: Array<string>): MoneroNodeSettings;
|
|
clearStartupFlagsList(): MoneroNodeSettings;
|
|
addStartupFlags(value: string, index?: number): MoneroNodeSettings;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): MoneroNodeSettings.AsObject;
|
|
static toObject(includeInstance: boolean, msg: MoneroNodeSettings): MoneroNodeSettings.AsObject;
|
|
static serializeBinaryToWriter(message: MoneroNodeSettings, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): MoneroNodeSettings;
|
|
static deserializeBinaryFromReader(message: MoneroNodeSettings, reader: jspb.BinaryReader): MoneroNodeSettings;
|
|
}
|
|
|
|
export namespace MoneroNodeSettings {
|
|
export type AsObject = {
|
|
blockchainPath: string,
|
|
bootstrapUrl: string,
|
|
startupFlagsList: Array<string>,
|
|
}
|
|
}
|
|
|
|
export class UserPayload extends jspb.Message {
|
|
getAccountId(): string;
|
|
setAccountId(value: string): UserPayload;
|
|
|
|
getPaymentAccountsList(): Array<PaymentAccount>;
|
|
setPaymentAccountsList(value: Array<PaymentAccount>): UserPayload;
|
|
clearPaymentAccountsList(): UserPayload;
|
|
addPaymentAccounts(value?: PaymentAccount, index?: number): PaymentAccount;
|
|
|
|
getCurrentPaymentAccount(): PaymentAccount | undefined;
|
|
setCurrentPaymentAccount(value?: PaymentAccount): UserPayload;
|
|
hasCurrentPaymentAccount(): boolean;
|
|
clearCurrentPaymentAccount(): UserPayload;
|
|
|
|
getAcceptedLanguageLocaleCodesList(): Array<string>;
|
|
setAcceptedLanguageLocaleCodesList(value: Array<string>): UserPayload;
|
|
clearAcceptedLanguageLocaleCodesList(): UserPayload;
|
|
addAcceptedLanguageLocaleCodes(value: string, index?: number): UserPayload;
|
|
|
|
getDevelopersAlert(): Alert | undefined;
|
|
setDevelopersAlert(value?: Alert): UserPayload;
|
|
hasDevelopersAlert(): boolean;
|
|
clearDevelopersAlert(): UserPayload;
|
|
|
|
getDisplayedAlert(): Alert | undefined;
|
|
setDisplayedAlert(value?: Alert): UserPayload;
|
|
hasDisplayedAlert(): boolean;
|
|
clearDisplayedAlert(): UserPayload;
|
|
|
|
getDevelopersFilter(): Filter | undefined;
|
|
setDevelopersFilter(value?: Filter): UserPayload;
|
|
hasDevelopersFilter(): boolean;
|
|
clearDevelopersFilter(): UserPayload;
|
|
|
|
getAcceptedArbitratorsList(): Array<Arbitrator>;
|
|
setAcceptedArbitratorsList(value: Array<Arbitrator>): UserPayload;
|
|
clearAcceptedArbitratorsList(): UserPayload;
|
|
addAcceptedArbitrators(value?: Arbitrator, index?: number): Arbitrator;
|
|
|
|
getAcceptedMediatorsList(): Array<Mediator>;
|
|
setAcceptedMediatorsList(value: Array<Mediator>): UserPayload;
|
|
clearAcceptedMediatorsList(): UserPayload;
|
|
addAcceptedMediators(value?: Mediator, index?: number): Mediator;
|
|
|
|
getRegisteredArbitrator(): Arbitrator | undefined;
|
|
setRegisteredArbitrator(value?: Arbitrator): UserPayload;
|
|
hasRegisteredArbitrator(): boolean;
|
|
clearRegisteredArbitrator(): UserPayload;
|
|
|
|
getRegisteredMediator(): Mediator | undefined;
|
|
setRegisteredMediator(value?: Mediator): UserPayload;
|
|
hasRegisteredMediator(): boolean;
|
|
clearRegisteredMediator(): UserPayload;
|
|
|
|
getPriceAlertFilter(): PriceAlertFilter | undefined;
|
|
setPriceAlertFilter(value?: PriceAlertFilter): UserPayload;
|
|
hasPriceAlertFilter(): boolean;
|
|
clearPriceAlertFilter(): UserPayload;
|
|
|
|
getMarketAlertFiltersList(): Array<MarketAlertFilter>;
|
|
setMarketAlertFiltersList(value: Array<MarketAlertFilter>): UserPayload;
|
|
clearMarketAlertFiltersList(): UserPayload;
|
|
addMarketAlertFilters(value?: MarketAlertFilter, index?: number): MarketAlertFilter;
|
|
|
|
getAcceptedRefundAgentsList(): Array<RefundAgent>;
|
|
setAcceptedRefundAgentsList(value: Array<RefundAgent>): UserPayload;
|
|
clearAcceptedRefundAgentsList(): UserPayload;
|
|
addAcceptedRefundAgents(value?: RefundAgent, index?: number): RefundAgent;
|
|
|
|
getRegisteredRefundAgent(): RefundAgent | undefined;
|
|
setRegisteredRefundAgent(value?: RefundAgent): UserPayload;
|
|
hasRegisteredRefundAgent(): boolean;
|
|
clearRegisteredRefundAgent(): UserPayload;
|
|
|
|
getCookieMap(): jspb.Map<string, string>;
|
|
clearCookieMap(): UserPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): UserPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: UserPayload): UserPayload.AsObject;
|
|
static serializeBinaryToWriter(message: UserPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): UserPayload;
|
|
static deserializeBinaryFromReader(message: UserPayload, reader: jspb.BinaryReader): UserPayload;
|
|
}
|
|
|
|
export namespace UserPayload {
|
|
export type AsObject = {
|
|
accountId: string,
|
|
paymentAccountsList: Array<PaymentAccount.AsObject>,
|
|
currentPaymentAccount?: PaymentAccount.AsObject,
|
|
acceptedLanguageLocaleCodesList: Array<string>,
|
|
developersAlert?: Alert.AsObject,
|
|
displayedAlert?: Alert.AsObject,
|
|
developersFilter?: Filter.AsObject,
|
|
acceptedArbitratorsList: Array<Arbitrator.AsObject>,
|
|
acceptedMediatorsList: Array<Mediator.AsObject>,
|
|
registeredArbitrator?: Arbitrator.AsObject,
|
|
registeredMediator?: Mediator.AsObject,
|
|
priceAlertFilter?: PriceAlertFilter.AsObject,
|
|
marketAlertFiltersList: Array<MarketAlertFilter.AsObject>,
|
|
acceptedRefundAgentsList: Array<RefundAgent.AsObject>,
|
|
registeredRefundAgent?: RefundAgent.AsObject,
|
|
cookieMap: Array<[string, string]>,
|
|
}
|
|
}
|
|
|
|
export class BlockChainExplorer extends jspb.Message {
|
|
getName(): string;
|
|
setName(value: string): BlockChainExplorer;
|
|
|
|
getTxUrl(): string;
|
|
setTxUrl(value: string): BlockChainExplorer;
|
|
|
|
getAddressUrl(): string;
|
|
setAddressUrl(value: string): BlockChainExplorer;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): BlockChainExplorer.AsObject;
|
|
static toObject(includeInstance: boolean, msg: BlockChainExplorer): BlockChainExplorer.AsObject;
|
|
static serializeBinaryToWriter(message: BlockChainExplorer, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): BlockChainExplorer;
|
|
static deserializeBinaryFromReader(message: BlockChainExplorer, reader: jspb.BinaryReader): BlockChainExplorer;
|
|
}
|
|
|
|
export namespace BlockChainExplorer {
|
|
export type AsObject = {
|
|
name: string,
|
|
txUrl: string,
|
|
addressUrl: string,
|
|
}
|
|
}
|
|
|
|
export class PaymentAccount extends jspb.Message {
|
|
getId(): string;
|
|
setId(value: string): PaymentAccount;
|
|
|
|
getCreationDate(): string;
|
|
setCreationDate(value: string): PaymentAccount;
|
|
|
|
getPaymentMethod(): PaymentMethod | undefined;
|
|
setPaymentMethod(value?: PaymentMethod): PaymentAccount;
|
|
hasPaymentMethod(): boolean;
|
|
clearPaymentMethod(): PaymentAccount;
|
|
|
|
getAccountName(): string;
|
|
setAccountName(value: string): PaymentAccount;
|
|
|
|
getTradeCurrenciesList(): Array<TradeCurrency>;
|
|
setTradeCurrenciesList(value: Array<TradeCurrency>): PaymentAccount;
|
|
clearTradeCurrenciesList(): PaymentAccount;
|
|
addTradeCurrencies(value?: TradeCurrency, index?: number): TradeCurrency;
|
|
|
|
getSelectedTradeCurrency(): TradeCurrency | undefined;
|
|
setSelectedTradeCurrency(value?: TradeCurrency): PaymentAccount;
|
|
hasSelectedTradeCurrency(): boolean;
|
|
clearSelectedTradeCurrency(): PaymentAccount;
|
|
|
|
getPaymentAccountPayload(): PaymentAccountPayload | undefined;
|
|
setPaymentAccountPayload(value?: PaymentAccountPayload): PaymentAccount;
|
|
hasPaymentAccountPayload(): boolean;
|
|
clearPaymentAccountPayload(): PaymentAccount;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PaymentAccount.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PaymentAccount): PaymentAccount.AsObject;
|
|
static serializeBinaryToWriter(message: PaymentAccount, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PaymentAccount;
|
|
static deserializeBinaryFromReader(message: PaymentAccount, reader: jspb.BinaryReader): PaymentAccount;
|
|
}
|
|
|
|
export namespace PaymentAccount {
|
|
export type AsObject = {
|
|
id: string,
|
|
creationDate: string,
|
|
paymentMethod?: PaymentMethod.AsObject,
|
|
accountName: string,
|
|
tradeCurrenciesList: Array<TradeCurrency.AsObject>,
|
|
selectedTradeCurrency?: TradeCurrency.AsObject,
|
|
paymentAccountPayload?: PaymentAccountPayload.AsObject,
|
|
}
|
|
}
|
|
|
|
export class PaymentMethod extends jspb.Message {
|
|
getId(): string;
|
|
setId(value: string): PaymentMethod;
|
|
|
|
getMaxTradePeriod(): string;
|
|
setMaxTradePeriod(value: string): PaymentMethod;
|
|
|
|
getMaxTradeLimit(): string;
|
|
setMaxTradeLimit(value: string): PaymentMethod;
|
|
|
|
getSupportedAssetCodesList(): Array<string>;
|
|
setSupportedAssetCodesList(value: Array<string>): PaymentMethod;
|
|
clearSupportedAssetCodesList(): PaymentMethod;
|
|
addSupportedAssetCodes(value: string, index?: number): PaymentMethod;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PaymentMethod.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PaymentMethod): PaymentMethod.AsObject;
|
|
static serializeBinaryToWriter(message: PaymentMethod, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PaymentMethod;
|
|
static deserializeBinaryFromReader(message: PaymentMethod, reader: jspb.BinaryReader): PaymentMethod;
|
|
}
|
|
|
|
export namespace PaymentMethod {
|
|
export type AsObject = {
|
|
id: string,
|
|
maxTradePeriod: string,
|
|
maxTradeLimit: string,
|
|
supportedAssetCodesList: Array<string>,
|
|
}
|
|
}
|
|
|
|
export class Currency extends jspb.Message {
|
|
getCurrencyCode(): string;
|
|
setCurrencyCode(value: string): Currency;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): Currency.AsObject;
|
|
static toObject(includeInstance: boolean, msg: Currency): Currency.AsObject;
|
|
static serializeBinaryToWriter(message: Currency, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): Currency;
|
|
static deserializeBinaryFromReader(message: Currency, reader: jspb.BinaryReader): Currency;
|
|
}
|
|
|
|
export namespace Currency {
|
|
export type AsObject = {
|
|
currencyCode: string,
|
|
}
|
|
}
|
|
|
|
export class TradeCurrency extends jspb.Message {
|
|
getCode(): string;
|
|
setCode(value: string): TradeCurrency;
|
|
|
|
getName(): string;
|
|
setName(value: string): TradeCurrency;
|
|
|
|
getCryptoCurrency(): CryptoCurrency | undefined;
|
|
setCryptoCurrency(value?: CryptoCurrency): TradeCurrency;
|
|
hasCryptoCurrency(): boolean;
|
|
clearCryptoCurrency(): TradeCurrency;
|
|
|
|
getFiatCurrency(): FiatCurrency | undefined;
|
|
setFiatCurrency(value?: FiatCurrency): TradeCurrency;
|
|
hasFiatCurrency(): boolean;
|
|
clearFiatCurrency(): TradeCurrency;
|
|
|
|
getMessageCase(): TradeCurrency.MessageCase;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): TradeCurrency.AsObject;
|
|
static toObject(includeInstance: boolean, msg: TradeCurrency): TradeCurrency.AsObject;
|
|
static serializeBinaryToWriter(message: TradeCurrency, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): TradeCurrency;
|
|
static deserializeBinaryFromReader(message: TradeCurrency, reader: jspb.BinaryReader): TradeCurrency;
|
|
}
|
|
|
|
export namespace TradeCurrency {
|
|
export type AsObject = {
|
|
code: string,
|
|
name: string,
|
|
cryptoCurrency?: CryptoCurrency.AsObject,
|
|
fiatCurrency?: FiatCurrency.AsObject,
|
|
}
|
|
|
|
export enum MessageCase {
|
|
MESSAGE_NOT_SET = 0,
|
|
CRYPTO_CURRENCY = 3,
|
|
FIAT_CURRENCY = 4,
|
|
}
|
|
}
|
|
|
|
export class CryptoCurrency extends jspb.Message {
|
|
getIsAsset(): boolean;
|
|
setIsAsset(value: boolean): CryptoCurrency;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): CryptoCurrency.AsObject;
|
|
static toObject(includeInstance: boolean, msg: CryptoCurrency): CryptoCurrency.AsObject;
|
|
static serializeBinaryToWriter(message: CryptoCurrency, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): CryptoCurrency;
|
|
static deserializeBinaryFromReader(message: CryptoCurrency, reader: jspb.BinaryReader): CryptoCurrency;
|
|
}
|
|
|
|
export namespace CryptoCurrency {
|
|
export type AsObject = {
|
|
isAsset: boolean,
|
|
}
|
|
}
|
|
|
|
export class FiatCurrency extends jspb.Message {
|
|
getCurrency(): Currency | undefined;
|
|
setCurrency(value?: Currency): FiatCurrency;
|
|
hasCurrency(): boolean;
|
|
clearCurrency(): FiatCurrency;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): FiatCurrency.AsObject;
|
|
static toObject(includeInstance: boolean, msg: FiatCurrency): FiatCurrency.AsObject;
|
|
static serializeBinaryToWriter(message: FiatCurrency, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): FiatCurrency;
|
|
static deserializeBinaryFromReader(message: FiatCurrency, reader: jspb.BinaryReader): FiatCurrency;
|
|
}
|
|
|
|
export namespace FiatCurrency {
|
|
export type AsObject = {
|
|
currency?: Currency.AsObject,
|
|
}
|
|
}
|
|
|
|
export class Country extends jspb.Message {
|
|
getCode(): string;
|
|
setCode(value: string): Country;
|
|
|
|
getName(): string;
|
|
setName(value: string): Country;
|
|
|
|
getRegion(): Region | undefined;
|
|
setRegion(value?: Region): Country;
|
|
hasRegion(): boolean;
|
|
clearRegion(): Country;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): Country.AsObject;
|
|
static toObject(includeInstance: boolean, msg: Country): Country.AsObject;
|
|
static serializeBinaryToWriter(message: Country, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): Country;
|
|
static deserializeBinaryFromReader(message: Country, reader: jspb.BinaryReader): Country;
|
|
}
|
|
|
|
export namespace Country {
|
|
export type AsObject = {
|
|
code: string,
|
|
name: string,
|
|
region?: Region.AsObject,
|
|
}
|
|
}
|
|
|
|
export class Region extends jspb.Message {
|
|
getCode(): string;
|
|
setCode(value: string): Region;
|
|
|
|
getName(): string;
|
|
setName(value: string): Region;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): Region.AsObject;
|
|
static toObject(includeInstance: boolean, msg: Region): Region.AsObject;
|
|
static serializeBinaryToWriter(message: Region, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): Region;
|
|
static deserializeBinaryFromReader(message: Region, reader: jspb.BinaryReader): Region;
|
|
}
|
|
|
|
export namespace Region {
|
|
export type AsObject = {
|
|
code: string,
|
|
name: string,
|
|
}
|
|
}
|
|
|
|
export class PriceAlertFilter extends jspb.Message {
|
|
getCurrencycode(): string;
|
|
setCurrencycode(value: string): PriceAlertFilter;
|
|
|
|
getHigh(): number;
|
|
setHigh(value: number): PriceAlertFilter;
|
|
|
|
getLow(): number;
|
|
setLow(value: number): PriceAlertFilter;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PriceAlertFilter.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PriceAlertFilter): PriceAlertFilter.AsObject;
|
|
static serializeBinaryToWriter(message: PriceAlertFilter, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PriceAlertFilter;
|
|
static deserializeBinaryFromReader(message: PriceAlertFilter, reader: jspb.BinaryReader): PriceAlertFilter;
|
|
}
|
|
|
|
export namespace PriceAlertFilter {
|
|
export type AsObject = {
|
|
currencycode: string,
|
|
high: number,
|
|
low: number,
|
|
}
|
|
}
|
|
|
|
export class MarketAlertFilter extends jspb.Message {
|
|
getPaymentAccount(): PaymentAccount | undefined;
|
|
setPaymentAccount(value?: PaymentAccount): MarketAlertFilter;
|
|
hasPaymentAccount(): boolean;
|
|
clearPaymentAccount(): MarketAlertFilter;
|
|
|
|
getTriggerValue(): number;
|
|
setTriggerValue(value: number): MarketAlertFilter;
|
|
|
|
getIsBuyOffer(): boolean;
|
|
setIsBuyOffer(value: boolean): MarketAlertFilter;
|
|
|
|
getAlertIdsList(): Array<string>;
|
|
setAlertIdsList(value: Array<string>): MarketAlertFilter;
|
|
clearAlertIdsList(): MarketAlertFilter;
|
|
addAlertIds(value: string, index?: number): MarketAlertFilter;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): MarketAlertFilter.AsObject;
|
|
static toObject(includeInstance: boolean, msg: MarketAlertFilter): MarketAlertFilter.AsObject;
|
|
static serializeBinaryToWriter(message: MarketAlertFilter, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): MarketAlertFilter;
|
|
static deserializeBinaryFromReader(message: MarketAlertFilter, reader: jspb.BinaryReader): MarketAlertFilter;
|
|
}
|
|
|
|
export namespace MarketAlertFilter {
|
|
export type AsObject = {
|
|
paymentAccount?: PaymentAccount.AsObject,
|
|
triggerValue: number,
|
|
isBuyOffer: boolean,
|
|
alertIdsList: Array<string>,
|
|
}
|
|
}
|
|
|
|
export class MockMailboxPayload extends jspb.Message {
|
|
getMessage(): string;
|
|
setMessage(value: string): MockMailboxPayload;
|
|
|
|
getSenderNodeAddress(): NodeAddress | undefined;
|
|
setSenderNodeAddress(value?: NodeAddress): MockMailboxPayload;
|
|
hasSenderNodeAddress(): boolean;
|
|
clearSenderNodeAddress(): MockMailboxPayload;
|
|
|
|
getUid(): string;
|
|
setUid(value: string): MockMailboxPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): MockMailboxPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: MockMailboxPayload): MockMailboxPayload.AsObject;
|
|
static serializeBinaryToWriter(message: MockMailboxPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): MockMailboxPayload;
|
|
static deserializeBinaryFromReader(message: MockMailboxPayload, reader: jspb.BinaryReader): MockMailboxPayload;
|
|
}
|
|
|
|
export namespace MockMailboxPayload {
|
|
export type AsObject = {
|
|
message: string,
|
|
senderNodeAddress?: NodeAddress.AsObject,
|
|
uid: string,
|
|
}
|
|
}
|
|
|
|
export class MockPayload extends jspb.Message {
|
|
getMessageVersion(): string;
|
|
setMessageVersion(value: string): MockPayload;
|
|
|
|
getMessage(): string;
|
|
setMessage(value: string): MockPayload;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): MockPayload.AsObject;
|
|
static toObject(includeInstance: boolean, msg: MockPayload): MockPayload.AsObject;
|
|
static serializeBinaryToWriter(message: MockPayload, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): MockPayload;
|
|
static deserializeBinaryFromReader(message: MockPayload, reader: jspb.BinaryReader): MockPayload;
|
|
}
|
|
|
|
export namespace MockPayload {
|
|
export type AsObject = {
|
|
messageVersion: string,
|
|
message: string,
|
|
}
|
|
}
|
|
|
|
export class PaymentAccountForm extends jspb.Message {
|
|
getId(): PaymentAccountForm.FormId;
|
|
setId(value: PaymentAccountForm.FormId): PaymentAccountForm;
|
|
|
|
getFieldsList(): Array<PaymentAccountFormField>;
|
|
setFieldsList(value: Array<PaymentAccountFormField>): PaymentAccountForm;
|
|
clearFieldsList(): PaymentAccountForm;
|
|
addFields(value?: PaymentAccountFormField, index?: number): PaymentAccountFormField;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PaymentAccountForm.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PaymentAccountForm): PaymentAccountForm.AsObject;
|
|
static serializeBinaryToWriter(message: PaymentAccountForm, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PaymentAccountForm;
|
|
static deserializeBinaryFromReader(message: PaymentAccountForm, reader: jspb.BinaryReader): PaymentAccountForm;
|
|
}
|
|
|
|
export namespace PaymentAccountForm {
|
|
export type AsObject = {
|
|
id: PaymentAccountForm.FormId,
|
|
fieldsList: Array<PaymentAccountFormField.AsObject>,
|
|
}
|
|
|
|
export enum FormId {
|
|
BLOCK_CHAINS = 0,
|
|
REVOLUT = 1,
|
|
SEPA = 2,
|
|
SEPA_INSTANT = 3,
|
|
TRANSFERWISE = 4,
|
|
CLEAR_X_CHANGE = 5,
|
|
SWIFT = 6,
|
|
F2F = 7,
|
|
STRIKE = 8,
|
|
MONEY_GRAM = 9,
|
|
FASTER_PAYMENTS = 10,
|
|
UPHOLD = 11,
|
|
PAXUM = 12,
|
|
}
|
|
}
|
|
|
|
export class PaymentAccountFormField extends jspb.Message {
|
|
getId(): PaymentAccountFormField.FieldId;
|
|
setId(value: PaymentAccountFormField.FieldId): PaymentAccountFormField;
|
|
|
|
getComponent(): PaymentAccountFormField.Component;
|
|
setComponent(value: PaymentAccountFormField.Component): PaymentAccountFormField;
|
|
|
|
getType(): string;
|
|
setType(value: string): PaymentAccountFormField;
|
|
|
|
getLabel(): string;
|
|
setLabel(value: string): PaymentAccountFormField;
|
|
|
|
getValue(): string;
|
|
setValue(value: string): PaymentAccountFormField;
|
|
|
|
getMinlength(): number;
|
|
setMinlength(value: number): PaymentAccountFormField;
|
|
|
|
getMaxlength(): number;
|
|
setMaxlength(value: number): PaymentAccountFormField;
|
|
|
|
getSupportedCurrenciesList(): Array<TradeCurrency>;
|
|
setSupportedCurrenciesList(value: Array<TradeCurrency>): PaymentAccountFormField;
|
|
clearSupportedCurrenciesList(): PaymentAccountFormField;
|
|
addSupportedCurrencies(value?: TradeCurrency, index?: number): TradeCurrency;
|
|
|
|
getSupportedCountriesList(): Array<Country>;
|
|
setSupportedCountriesList(value: Array<Country>): PaymentAccountFormField;
|
|
clearSupportedCountriesList(): PaymentAccountFormField;
|
|
addSupportedCountries(value?: Country, index?: number): Country;
|
|
|
|
getSupportedSepaEuroCountriesList(): Array<Country>;
|
|
setSupportedSepaEuroCountriesList(value: Array<Country>): PaymentAccountFormField;
|
|
clearSupportedSepaEuroCountriesList(): PaymentAccountFormField;
|
|
addSupportedSepaEuroCountries(value?: Country, index?: number): Country;
|
|
|
|
getSupportedSepaNonEuroCountriesList(): Array<Country>;
|
|
setSupportedSepaNonEuroCountriesList(value: Array<Country>): PaymentAccountFormField;
|
|
clearSupportedSepaNonEuroCountriesList(): PaymentAccountFormField;
|
|
addSupportedSepaNonEuroCountries(value?: Country, index?: number): Country;
|
|
|
|
getRequiredForCountriesList(): Array<string>;
|
|
setRequiredForCountriesList(value: Array<string>): PaymentAccountFormField;
|
|
clearRequiredForCountriesList(): PaymentAccountFormField;
|
|
addRequiredForCountries(value: string, index?: number): PaymentAccountFormField;
|
|
|
|
serializeBinary(): Uint8Array;
|
|
toObject(includeInstance?: boolean): PaymentAccountFormField.AsObject;
|
|
static toObject(includeInstance: boolean, msg: PaymentAccountFormField): PaymentAccountFormField.AsObject;
|
|
static serializeBinaryToWriter(message: PaymentAccountFormField, writer: jspb.BinaryWriter): void;
|
|
static deserializeBinary(bytes: Uint8Array): PaymentAccountFormField;
|
|
static deserializeBinaryFromReader(message: PaymentAccountFormField, reader: jspb.BinaryReader): PaymentAccountFormField;
|
|
}
|
|
|
|
export namespace PaymentAccountFormField {
|
|
export type AsObject = {
|
|
id: PaymentAccountFormField.FieldId,
|
|
component: PaymentAccountFormField.Component,
|
|
type: string,
|
|
label: string,
|
|
value: string,
|
|
minlength: number,
|
|
maxlength: number,
|
|
supportedCurrenciesList: Array<TradeCurrency.AsObject>,
|
|
supportedCountriesList: Array<Country.AsObject>,
|
|
supportedSepaEuroCountriesList: Array<Country.AsObject>,
|
|
supportedSepaNonEuroCountriesList: Array<Country.AsObject>,
|
|
requiredForCountriesList: Array<string>,
|
|
}
|
|
|
|
export enum FieldId {
|
|
ADDRESS = 0,
|
|
ACCEPTED_COUNTRY_CODES = 1,
|
|
ACCOUNT_ID = 2,
|
|
ACCOUNT_NAME = 3,
|
|
ACCOUNT_NR = 4,
|
|
ACCOUNT_OWNER = 5,
|
|
ACCOUNT_TYPE = 6,
|
|
ANSWER = 7,
|
|
BANK_ACCOUNT_NAME = 8,
|
|
BANK_ACCOUNT_NUMBER = 9,
|
|
BANK_ACCOUNT_TYPE = 10,
|
|
BANK_ADDRESS = 11,
|
|
BANK_BRANCH = 12,
|
|
BANK_BRANCH_CODE = 13,
|
|
BANK_BRANCH_NAME = 14,
|
|
BANK_CODE = 15,
|
|
BANK_COUNTRY_CODE = 16,
|
|
BANK_ID = 17,
|
|
BANK_NAME = 18,
|
|
BANK_SWIFT_CODE = 19,
|
|
BENEFICIARY_ACCOUNT_NR = 20,
|
|
BENEFICIARY_ADDRESS = 21,
|
|
BENEFICIARY_CITY = 22,
|
|
BENEFICIARY_NAME = 23,
|
|
BENEFICIARY_PHONE = 24,
|
|
BIC = 25,
|
|
BRANCH_ID = 26,
|
|
CITY = 27,
|
|
CONTACT = 28,
|
|
COUNTRY = 29,
|
|
EMAIL = 30,
|
|
EMAIL_OR_MOBILE_NR = 31,
|
|
EXTRA_INFO = 32,
|
|
HOLDER_ADDRESS = 33,
|
|
HOLDER_EMAIL = 34,
|
|
HOLDER_NAME = 35,
|
|
HOLDER_TAX_ID = 36,
|
|
IBAN = 37,
|
|
IFSC = 38,
|
|
INTERMEDIARY_ADDRESS = 39,
|
|
INTERMEDIARY_BRANCH = 40,
|
|
INTERMEDIARY_COUNTRY_CODE = 41,
|
|
INTERMEDIARY_NAME = 42,
|
|
INTERMEDIARY_SWIFT_CODE = 43,
|
|
MOBILE_NR = 44,
|
|
NATIONAL_ACCOUNT_ID = 45,
|
|
PAYID = 46,
|
|
PIX_KEY = 47,
|
|
POSTAL_ADDRESS = 48,
|
|
PROMPT_PAY_ID = 49,
|
|
QUESTION = 50,
|
|
REQUIREMENTS = 51,
|
|
SALT = 52,
|
|
SORT_CODE = 53,
|
|
SPECIAL_INSTRUCTIONS = 54,
|
|
STATE = 55,
|
|
TRADE_CURRENCIES = 56,
|
|
USER_NAME = 57,
|
|
}
|
|
|
|
export enum Component {
|
|
TEXT = 0,
|
|
TEXTAREA = 1,
|
|
SELECT_ONE = 2,
|
|
SELECT_MULTIPLE = 3,
|
|
}
|
|
}
|
|
|
|
export enum SupportType {
|
|
ARBITRATION = 0,
|
|
MEDIATION = 1,
|
|
TRADE = 2,
|
|
REFUND = 3,
|
|
}
|
|
export enum OfferDirection {
|
|
OFFER_DIRECTION_ERROR = 0,
|
|
BUY = 1,
|
|
SELL = 2,
|
|
}
|
|
export enum AvailabilityResult {
|
|
PB_ERROR = 0,
|
|
UNKNOWN_FAILURE = 1,
|
|
AVAILABLE = 2,
|
|
OFFER_TAKEN = 3,
|
|
PRICE_OUT_OF_TOLERANCE = 4,
|
|
MARKET_PRICE_NOT_AVAILABLE = 5,
|
|
NO_ARBITRATORS = 6,
|
|
NO_MEDIATORS = 7,
|
|
USER_IGNORED = 8,
|
|
MISSING_MANDATORY_CAPABILITY = 9,
|
|
NO_REFUND_AGENTS = 10,
|
|
UNCONF_TX_LIMIT_HIT = 11,
|
|
MAKER_DENIED_API_USER = 12,
|
|
PRICE_CHECK_FAILED = 13,
|
|
MAKER_DENIED_TAKER = 14,
|
|
}
|
|
export enum MediationResultState {
|
|
PB_ERROR_MEDIATION_RESULT = 0,
|
|
UNDEFINED_MEDIATION_RESULT = 1,
|
|
MEDIATION_RESULT_ACCEPTED = 2,
|
|
MEDIATION_RESULT_REJECTED = 3,
|
|
SIG_MSG_SENT = 4,
|
|
SIG_MSG_ARRIVED = 5,
|
|
SIG_MSG_IN_MAILBOX = 6,
|
|
SIG_MSG_SEND_FAILED = 7,
|
|
RECEIVED_SIG_MSG = 8,
|
|
PAYOUT_TX_PUBLISHED = 9,
|
|
PAYOUT_TX_PUBLISHED_MSG_SENT = 10,
|
|
PAYOUT_TX_PUBLISHED_MSG_ARRIVED = 11,
|
|
PAYOUT_TX_PUBLISHED_MSG_IN_MAILBOX = 12,
|
|
PAYOUT_TX_PUBLISHED_MSG_SEND_FAILED = 13,
|
|
RECEIVED_PAYOUT_TX_PUBLISHED_MSG = 14,
|
|
PAYOUT_TX_SEEN_IN_NETWORK = 15,
|
|
}
|
|
export enum RefundResultState {
|
|
PB_ERROR_REFUND_RESULT = 0,
|
|
UNDEFINED_REFUND_RESULT = 1,
|
|
}
|