// package: bet.beteran.c2se.member_balance
// file: c2se/member_balance.proto

import * as jspb from 'google-protobuf';
import * as protobuf_rpc_pb from '../protobuf/rpc_pb';
import * as protobuf_pagination_pb from '../protobuf/pagination_pb';
import * as models_member_balance_pb from '../models/member_balance_pb';

export class CreateMemberBalanceRequest extends jspb.Message {
  getMemberId(): string;
  setMemberId(value: string): void;

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

export namespace CreateMemberBalanceRequest {
  export type AsObject = {
    memberId: string;
  };
}

export class CreateMemberBalanceResponse extends jspb.Message {
  hasError(): boolean;
  clearError(): void;
  getError(): protobuf_rpc_pb.Error | undefined;
  setError(value?: protobuf_rpc_pb.Error): void;

  hasResult(): boolean;
  clearResult(): void;
  getResult(): CreateMemberBalanceResponse.Result | undefined;
  setResult(value?: CreateMemberBalanceResponse.Result): void;

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

export namespace CreateMemberBalanceResponse {
  export type AsObject = {
    error?: protobuf_rpc_pb.Error.AsObject;
    result?: CreateMemberBalanceResponse.Result.AsObject;
  };

  export class Result extends jspb.Message {
    hasMemberBalance(): boolean;
    clearMemberBalance(): void;
    getMemberBalance(): models_member_balance_pb.MemberBalance | undefined;
    setMemberBalance(value?: models_member_balance_pb.MemberBalance): void;

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

  export namespace Result {
    export type AsObject = {
      memberBalance?: models_member_balance_pb.MemberBalance.AsObject;
    };
  }
}

export class ListMemberBalancesRequest extends jspb.Message {
  hasPagination(): boolean;
  clearPagination(): void;
  getPagination(): protobuf_pagination_pb.Pagination | undefined;
  setPagination(value?: protobuf_pagination_pb.Pagination): void;

  clearSortsList(): void;
  getSortsList(): Array<protobuf_pagination_pb.Sort>;
  setSortsList(value: Array<protobuf_pagination_pb.Sort>): void;
  addSorts(
    value?: protobuf_pagination_pb.Sort,
    index?: number
  ): protobuf_pagination_pb.Sort;

  hasSearch(): boolean;
  clearSearch(): void;
  getSearch(): ListMemberBalancesRequest.Search | undefined;
  setSearch(value?: ListMemberBalancesRequest.Search): void;

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

export namespace ListMemberBalancesRequest {
  export type AsObject = {
    pagination?: protobuf_pagination_pb.Pagination.AsObject;
    sortsList: Array<protobuf_pagination_pb.Sort.AsObject>;
    search?: ListMemberBalancesRequest.Search.AsObject;
  };

  export class Search extends jspb.Message {
    hasMemberId(): boolean;
    clearMemberId(): void;
    getMemberId(): string;
    setMemberId(value: string): void;

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

  export namespace Search {
    export type AsObject = {
      memberId: string;
    };
  }
}

export class ListMemberBalancesResponse extends jspb.Message {
  hasError(): boolean;
  clearError(): void;
  getError(): protobuf_rpc_pb.Error | undefined;
  setError(value?: protobuf_rpc_pb.Error): void;

  hasResult(): boolean;
  clearResult(): void;
  getResult(): ListMemberBalancesResponse.Result | undefined;
  setResult(value?: ListMemberBalancesResponse.Result): void;

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

export namespace ListMemberBalancesResponse {
  export type AsObject = {
    error?: protobuf_rpc_pb.Error.AsObject;
    result?: ListMemberBalancesResponse.Result.AsObject;
  };

  export class Result extends jspb.Message {
    getTotalCount(): number;
    setTotalCount(value: number): void;

    clearMemberBalancesList(): void;
    getMemberBalancesList(): Array<models_member_balance_pb.MemberBalance>;
    setMemberBalancesList(
      value: Array<models_member_balance_pb.MemberBalance>
    ): void;
    addMemberBalances(
      value?: models_member_balance_pb.MemberBalance,
      index?: number
    ): models_member_balance_pb.MemberBalance;

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

  export namespace Result {
    export type AsObject = {
      totalCount: number;
      memberBalancesList: Array<models_member_balance_pb.MemberBalance.AsObject>;
    };
  }
}

export class GetMemberBalanceRequest extends jspb.Message {
  getId(): string;
  setId(value: string): void;

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

export namespace GetMemberBalanceRequest {
  export type AsObject = {
    id: string;
  };
}

export class GetMemberBalanceResponse extends jspb.Message {
  hasError(): boolean;
  clearError(): void;
  getError(): protobuf_rpc_pb.Error | undefined;
  setError(value?: protobuf_rpc_pb.Error): void;

  hasResult(): boolean;
  clearResult(): void;
  getResult(): GetMemberBalanceResponse.Result | undefined;
  setResult(value?: GetMemberBalanceResponse.Result): void;

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

export namespace GetMemberBalanceResponse {
  export type AsObject = {
    error?: protobuf_rpc_pb.Error.AsObject;
    result?: GetMemberBalanceResponse.Result.AsObject;
  };

  export class Result extends jspb.Message {
    hasMemberBalance(): boolean;
    clearMemberBalance(): void;
    getMemberBalance(): models_member_balance_pb.MemberBalance | undefined;
    setMemberBalance(value?: models_member_balance_pb.MemberBalance): void;

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

  export namespace Result {
    export type AsObject = {
      memberBalance?: models_member_balance_pb.MemberBalance.AsObject;
    };
  }
}

export class UpdateMemberBalanceRequest extends jspb.Message {
  getId(): string;
  setId(value: string): void;

  getBalance(): number;
  setBalance(value: number): void;

  getBalanceBota(): number;
  setBalanceBota(value: number): void;

  getBalanceSum(): number;
  setBalanceSum(value: number): void;

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

export namespace UpdateMemberBalanceRequest {
  export type AsObject = {
    id: string;
    balance: number;
    balanceBota: number;
    balanceSum: number;
  };
}

export class UpdateMemberBalanceResponse extends jspb.Message {
  hasError(): boolean;
  clearError(): void;
  getError(): protobuf_rpc_pb.Error | undefined;
  setError(value?: protobuf_rpc_pb.Error): void;

  hasResult(): boolean;
  clearResult(): void;
  getResult(): UpdateMemberBalanceResponse.Result | undefined;
  setResult(value?: UpdateMemberBalanceResponse.Result): void;

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

export namespace UpdateMemberBalanceResponse {
  export type AsObject = {
    error?: protobuf_rpc_pb.Error.AsObject;
    result?: UpdateMemberBalanceResponse.Result.AsObject;
  };

  export class Result extends jspb.Message {
    hasMemberBalance(): boolean;
    clearMemberBalance(): void;
    getMemberBalance(): models_member_balance_pb.MemberBalance | undefined;
    setMemberBalance(value?: models_member_balance_pb.MemberBalance): void;

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

  export namespace Result {
    export type AsObject = {
      memberBalance?: models_member_balance_pb.MemberBalance.AsObject;
    };
  }
}

export class DeleteMemberBalanceRequest extends jspb.Message {
  getId(): string;
  setId(value: string): void;

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

export namespace DeleteMemberBalanceRequest {
  export type AsObject = {
    id: string;
  };
}

export class DeleteMemberBalanceResponse extends jspb.Message {
  hasError(): boolean;
  clearError(): void;
  getError(): protobuf_rpc_pb.Error | undefined;
  setError(value?: protobuf_rpc_pb.Error): void;

  hasResult(): boolean;
  clearResult(): void;
  getResult(): DeleteMemberBalanceResponse.Result | undefined;
  setResult(value?: DeleteMemberBalanceResponse.Result): void;

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

export namespace DeleteMemberBalanceResponse {
  export type AsObject = {
    error?: protobuf_rpc_pb.Error.AsObject;
    result?: DeleteMemberBalanceResponse.Result.AsObject;
  };

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

  export namespace Result {
    export type AsObject = {};
  }
}
