// package: injective_accounts_rpc
// file: injective_accounts_rpc.proto

import * as jspb from "google-protobuf";

export class PortfolioRequest extends jspb.Message {
  getAccountAddress(): string;
  setAccountAddress(value: string): void;

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

export namespace PortfolioRequest {
  export type AsObject = {
    accountAddress: string,
  }
}

export class PortfolioResponse extends jspb.Message {
  hasPortfolio(): boolean;
  clearPortfolio(): void;
  getPortfolio(): AccountPortfolio | undefined;
  setPortfolio(value?: AccountPortfolio): void;

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

export namespace PortfolioResponse {
  export type AsObject = {
    portfolio?: AccountPortfolio.AsObject,
  }
}

export class AccountPortfolio extends jspb.Message {
  getPortfolioValue(): string;
  setPortfolioValue(value: string): void;

  getAvailableBalance(): string;
  setAvailableBalance(value: string): void;

  getLockedBalance(): string;
  setLockedBalance(value: string): void;

  getUnrealizedPnl(): string;
  setUnrealizedPnl(value: string): void;

  clearSubaccountsList(): void;
  getSubaccountsList(): Array<SubaccountPortfolio>;
  setSubaccountsList(value: Array<SubaccountPortfolio>): void;
  addSubaccounts(value?: SubaccountPortfolio, index?: number): SubaccountPortfolio;

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

export namespace AccountPortfolio {
  export type AsObject = {
    portfolioValue: string,
    availableBalance: string,
    lockedBalance: string,
    unrealizedPnl: string,
    subaccountsList: Array<SubaccountPortfolio.AsObject>,
  }
}

export class SubaccountPortfolio extends jspb.Message {
  getSubaccountId(): string;
  setSubaccountId(value: string): void;

  getAvailableBalance(): string;
  setAvailableBalance(value: string): void;

  getLockedBalance(): string;
  setLockedBalance(value: string): void;

  getUnrealizedPnl(): string;
  setUnrealizedPnl(value: string): void;

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

export namespace SubaccountPortfolio {
  export type AsObject = {
    subaccountId: string,
    availableBalance: string,
    lockedBalance: string,
    unrealizedPnl: string,
  }
}

export class OrderStatesRequest extends jspb.Message {
  clearSpotOrderHashesList(): void;
  getSpotOrderHashesList(): Array<string>;
  setSpotOrderHashesList(value: Array<string>): void;
  addSpotOrderHashes(value: string, index?: number): string;

  clearDerivativeOrderHashesList(): void;
  getDerivativeOrderHashesList(): Array<string>;
  setDerivativeOrderHashesList(value: Array<string>): void;
  addDerivativeOrderHashes(value: string, index?: number): string;

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

export namespace OrderStatesRequest {
  export type AsObject = {
    spotOrderHashesList: Array<string>,
    derivativeOrderHashesList: Array<string>,
  }
}

export class OrderStatesResponse extends jspb.Message {
  clearSpotOrderStatesList(): void;
  getSpotOrderStatesList(): Array<OrderStateRecord>;
  setSpotOrderStatesList(value: Array<OrderStateRecord>): void;
  addSpotOrderStates(value?: OrderStateRecord, index?: number): OrderStateRecord;

  clearDerivativeOrderStatesList(): void;
  getDerivativeOrderStatesList(): Array<OrderStateRecord>;
  setDerivativeOrderStatesList(value: Array<OrderStateRecord>): void;
  addDerivativeOrderStates(value?: OrderStateRecord, index?: number): OrderStateRecord;

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

export namespace OrderStatesResponse {
  export type AsObject = {
    spotOrderStatesList: Array<OrderStateRecord.AsObject>,
    derivativeOrderStatesList: Array<OrderStateRecord.AsObject>,
  }
}

export class OrderStateRecord extends jspb.Message {
  getOrderHash(): string;
  setOrderHash(value: string): void;

  getSubaccountId(): string;
  setSubaccountId(value: string): void;

  getMarketId(): string;
  setMarketId(value: string): void;

  getOrderType(): string;
  setOrderType(value: string): void;

  getOrderSide(): string;
  setOrderSide(value: string): void;

  getState(): string;
  setState(value: string): void;

  getQuantityFilled(): string;
  setQuantityFilled(value: string): void;

  getQuantityRemaining(): string;
  setQuantityRemaining(value: string): void;

  getCreatedAt(): number;
  setCreatedAt(value: number): void;

  getUpdatedAt(): number;
  setUpdatedAt(value: number): void;

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

export namespace OrderStateRecord {
  export type AsObject = {
    orderHash: string,
    subaccountId: string,
    marketId: string,
    orderType: string,
    orderSide: string,
    state: string,
    quantityFilled: string,
    quantityRemaining: string,
    createdAt: number,
    updatedAt: number,
  }
}

export class SubaccountsListRequest extends jspb.Message {
  getAccountAddress(): string;
  setAccountAddress(value: string): void;

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

export namespace SubaccountsListRequest {
  export type AsObject = {
    accountAddress: string,
  }
}

export class SubaccountsListResponse extends jspb.Message {
  clearSubaccountsList(): void;
  getSubaccountsList(): Array<string>;
  setSubaccountsList(value: Array<string>): void;
  addSubaccounts(value: string, index?: number): string;

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

export namespace SubaccountsListResponse {
  export type AsObject = {
    subaccountsList: Array<string>,
  }
}

export class SubaccountBalancesListRequest extends jspb.Message {
  getSubaccountId(): string;
  setSubaccountId(value: string): void;

  clearDenomsList(): void;
  getDenomsList(): Array<string>;
  setDenomsList(value: Array<string>): void;
  addDenoms(value: string, index?: number): string;

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

export namespace SubaccountBalancesListRequest {
  export type AsObject = {
    subaccountId: string,
    denomsList: Array<string>,
  }
}

export class SubaccountBalancesListResponse extends jspb.Message {
  clearBalancesList(): void;
  getBalancesList(): Array<SubaccountBalance>;
  setBalancesList(value: Array<SubaccountBalance>): void;
  addBalances(value?: SubaccountBalance, index?: number): SubaccountBalance;

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

export namespace SubaccountBalancesListResponse {
  export type AsObject = {
    balancesList: Array<SubaccountBalance.AsObject>,
  }
}

export class SubaccountBalance extends jspb.Message {
  getSubaccountId(): string;
  setSubaccountId(value: string): void;

  getAccountAddress(): string;
  setAccountAddress(value: string): void;

  getDenom(): string;
  setDenom(value: string): void;

  hasDeposit(): boolean;
  clearDeposit(): void;
  getDeposit(): SubaccountDeposit | undefined;
  setDeposit(value?: SubaccountDeposit): void;

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

export namespace SubaccountBalance {
  export type AsObject = {
    subaccountId: string,
    accountAddress: string,
    denom: string,
    deposit?: SubaccountDeposit.AsObject,
  }
}

export class SubaccountDeposit extends jspb.Message {
  getTotalBalance(): string;
  setTotalBalance(value: string): void;

  getAvailableBalance(): string;
  setAvailableBalance(value: string): void;

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

export namespace SubaccountDeposit {
  export type AsObject = {
    totalBalance: string,
    availableBalance: string,
  }
}

export class SubaccountBalanceRequest extends jspb.Message {
  getSubaccountId(): string;
  setSubaccountId(value: string): void;

  getDenom(): string;
  setDenom(value: string): void;

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

export namespace SubaccountBalanceRequest {
  export type AsObject = {
    subaccountId: string,
    denom: string,
  }
}

export class SubaccountBalanceResponse extends jspb.Message {
  hasBalance(): boolean;
  clearBalance(): void;
  getBalance(): SubaccountBalance | undefined;
  setBalance(value?: SubaccountBalance): void;

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

export namespace SubaccountBalanceResponse {
  export type AsObject = {
    balance?: SubaccountBalance.AsObject,
  }
}

export class StreamSubaccountBalanceRequest extends jspb.Message {
  getSubaccountId(): string;
  setSubaccountId(value: string): void;

  clearDenomsList(): void;
  getDenomsList(): Array<string>;
  setDenomsList(value: Array<string>): void;
  addDenoms(value: string, index?: number): string;

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

export namespace StreamSubaccountBalanceRequest {
  export type AsObject = {
    subaccountId: string,
    denomsList: Array<string>,
  }
}

export class StreamSubaccountBalanceResponse extends jspb.Message {
  hasBalance(): boolean;
  clearBalance(): void;
  getBalance(): SubaccountBalance | undefined;
  setBalance(value?: SubaccountBalance): void;

  getTimestamp(): number;
  setTimestamp(value: number): void;

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

export namespace StreamSubaccountBalanceResponse {
  export type AsObject = {
    balance?: SubaccountBalance.AsObject,
    timestamp: number,
  }
}

export class SubaccountHistoryRequest extends jspb.Message {
  getSubaccountId(): string;
  setSubaccountId(value: string): void;

  getDenom(): string;
  setDenom(value: string): void;

  clearTransferTypesList(): void;
  getTransferTypesList(): Array<string>;
  setTransferTypesList(value: Array<string>): void;
  addTransferTypes(value: string, index?: number): string;

  getSkip(): number;
  setSkip(value: number): void;

  getLimit(): number;
  setLimit(value: number): void;

  getEndTime(): number;
  setEndTime(value: number): void;

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

export namespace SubaccountHistoryRequest {
  export type AsObject = {
    subaccountId: string,
    denom: string,
    transferTypesList: Array<string>,
    skip: number,
    limit: number,
    endTime: number,
  }
}

export class SubaccountHistoryResponse extends jspb.Message {
  clearTransfersList(): void;
  getTransfersList(): Array<SubaccountBalanceTransfer>;
  setTransfersList(value: Array<SubaccountBalanceTransfer>): void;
  addTransfers(value?: SubaccountBalanceTransfer, index?: number): SubaccountBalanceTransfer;

  hasPaging(): boolean;
  clearPaging(): void;
  getPaging(): Paging | undefined;
  setPaging(value?: Paging): void;

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

export namespace SubaccountHistoryResponse {
  export type AsObject = {
    transfersList: Array<SubaccountBalanceTransfer.AsObject>,
    paging?: Paging.AsObject,
  }
}

export class SubaccountBalanceTransfer extends jspb.Message {
  getTransferType(): string;
  setTransferType(value: string): void;

  getSrcSubaccountId(): string;
  setSrcSubaccountId(value: string): void;

  getSrcAccountAddress(): string;
  setSrcAccountAddress(value: string): void;

  getDstSubaccountId(): string;
  setDstSubaccountId(value: string): void;

  getDstAccountAddress(): string;
  setDstAccountAddress(value: string): void;

  hasAmount(): boolean;
  clearAmount(): void;
  getAmount(): CosmosCoin | undefined;
  setAmount(value?: CosmosCoin): void;

  getExecutedAt(): number;
  setExecutedAt(value: number): void;

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

export namespace SubaccountBalanceTransfer {
  export type AsObject = {
    transferType: string,
    srcSubaccountId: string,
    srcAccountAddress: string,
    dstSubaccountId: string,
    dstAccountAddress: string,
    amount?: CosmosCoin.AsObject,
    executedAt: number,
  }
}

export class CosmosCoin extends jspb.Message {
  getDenom(): string;
  setDenom(value: string): void;

  getAmount(): string;
  setAmount(value: string): void;

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

export namespace CosmosCoin {
  export type AsObject = {
    denom: string,
    amount: string,
  }
}

export class Paging extends jspb.Message {
  getTotal(): number;
  setTotal(value: number): void;

  getFrom(): number;
  setFrom(value: number): void;

  getTo(): number;
  setTo(value: number): void;

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

export namespace Paging {
  export type AsObject = {
    total: number,
    from: number,
    to: number,
  }
}

export class SubaccountOrderSummaryRequest extends jspb.Message {
  getSubaccountId(): string;
  setSubaccountId(value: string): void;

  getMarketId(): string;
  setMarketId(value: string): void;

  getOrderDirection(): string;
  setOrderDirection(value: string): void;

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

export namespace SubaccountOrderSummaryRequest {
  export type AsObject = {
    subaccountId: string,
    marketId: string,
    orderDirection: string,
  }
}

export class SubaccountOrderSummaryResponse extends jspb.Message {
  getSpotOrdersTotal(): number;
  setSpotOrdersTotal(value: number): void;

  getDerivativeOrdersTotal(): number;
  setDerivativeOrdersTotal(value: number): void;

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

export namespace SubaccountOrderSummaryResponse {
  export type AsObject = {
    spotOrdersTotal: number,
    derivativeOrdersTotal: number,
  }
}

export class RewardsRequest extends jspb.Message {
  getEpoch(): number;
  setEpoch(value: number): void;

  getAccountAddress(): string;
  setAccountAddress(value: string): void;

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

export namespace RewardsRequest {
  export type AsObject = {
    epoch: number,
    accountAddress: string,
  }
}

export class RewardsResponse extends jspb.Message {
  clearRewardsList(): void;
  getRewardsList(): Array<Reward>;
  setRewardsList(value: Array<Reward>): void;
  addRewards(value?: Reward, index?: number): Reward;

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

export namespace RewardsResponse {
  export type AsObject = {
    rewardsList: Array<Reward.AsObject>,
  }
}

export class Reward extends jspb.Message {
  getAccountAddress(): string;
  setAccountAddress(value: string): void;

  clearRewardsList(): void;
  getRewardsList(): Array<Coin>;
  setRewardsList(value: Array<Coin>): void;
  addRewards(value?: Coin, index?: number): Coin;

  getDistributedAt(): number;
  setDistributedAt(value: number): void;

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

export namespace Reward {
  export type AsObject = {
    accountAddress: string,
    rewardsList: Array<Coin.AsObject>,
    distributedAt: number,
  }
}

export class Coin extends jspb.Message {
  getDenom(): string;
  setDenom(value: string): void;

  getAmount(): string;
  setAmount(value: string): void;

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

export namespace Coin {
  export type AsObject = {
    denom: string,
    amount: string,
  }
}