@dcl/protocol 1.0.0-4408137944.commit-a67c796 → 1.0.0-4427886959.commit-6b9dcb5

package/out-ts/decentraland/social/friendships/friendships.gen.ts

@@ -0,0 +1,1447 @@
+/* eslint-disable */
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+import { Empty } from "../../../google/protobuf/empty.gen";
+
+export const protobufPackage = "decentraland.social.friendships";
+
+/** Validation and anti-spam errors */
+export enum FriendshipErrorCode {
+  TOO_MANY_REQUESTS_SENT = 0,
+  NOT_ENOUGH_TIME_PASSED = 1,
+  BLOCKED_USER = 2,
+  NON_EXISTING_USER = 3,
+  INVALID_REQUEST = 4,
+  UNKNOWN = 5,
+  UNRECOGNIZED = -1,
+}
+
+export function friendshipErrorCodeFromJSON(object: any): FriendshipErrorCode {
+  switch (object) {
+    case 0:
+    case "TOO_MANY_REQUESTS_SENT":
+      return FriendshipErrorCode.TOO_MANY_REQUESTS_SENT;
+    case 1:
+    case "NOT_ENOUGH_TIME_PASSED":
+      return FriendshipErrorCode.NOT_ENOUGH_TIME_PASSED;
+    case 2:
+    case "BLOCKED_USER":
+      return FriendshipErrorCode.BLOCKED_USER;
+    case 3:
+    case "NON_EXISTING_USER":
+      return FriendshipErrorCode.NON_EXISTING_USER;
+    case 4:
+    case "INVALID_REQUEST":
+      return FriendshipErrorCode.INVALID_REQUEST;
+    case 5:
+    case "UNKNOWN":
+      return FriendshipErrorCode.UNKNOWN;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return FriendshipErrorCode.UNRECOGNIZED;
+  }
+}
+
+export function friendshipErrorCodeToJSON(object: FriendshipErrorCode): string {
+  switch (object) {
+    case FriendshipErrorCode.TOO_MANY_REQUESTS_SENT:
+      return "TOO_MANY_REQUESTS_SENT";
+    case FriendshipErrorCode.NOT_ENOUGH_TIME_PASSED:
+      return "NOT_ENOUGH_TIME_PASSED";
+    case FriendshipErrorCode.BLOCKED_USER:
+      return "BLOCKED_USER";
+    case FriendshipErrorCode.NON_EXISTING_USER:
+      return "NON_EXISTING_USER";
+    case FriendshipErrorCode.INVALID_REQUEST:
+      return "INVALID_REQUEST";
+    case FriendshipErrorCode.UNKNOWN:
+      return "UNKNOWN";
+    case FriendshipErrorCode.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+/** This message is a response that is sent from the server to the client */
+export interface FriendshipEventResponse {
+  body?:
+    | { $case: "request"; request: RequestResponse }
+    | { $case: "accept"; accept: AcceptResponse }
+    | { $case: "reject"; reject: RejectResponse }
+    | { $case: "delete"; delete: DeleteResponse }
+    | { $case: "cancel"; cancel: CancelResponse };
+}
+
+export interface FriendshipEventPayload {
+  body?:
+    | { $case: "request"; request: RequestPayload }
+    | { $case: "accept"; accept: AcceptPayload }
+    | { $case: "reject"; reject: RejectPayload }
+    | { $case: "delete"; delete: DeletePayload }
+    | { $case: "cancel"; cancel: CancelPayload };
+}
+
+export interface User {
+  address: string;
+}
+
+export interface Users {
+  users: User[];
+}
+
+export interface RequestResponse {
+  user: User | undefined;
+  createdAt: number;
+  message?: string | undefined;
+}
+
+export interface RequestPayload {
+  user: User | undefined;
+  message?: string | undefined;
+}
+
+export interface Requests {
+  /** Total amount of friendship requests */
+  total: number;
+  items: RequestResponse[];
+}
+
+export interface RequestEvents {
+  /** Requests the authed user have sent to users */
+  outgoing:
+    | Requests
+    | undefined;
+  /** Requests the authed user have received from users */
+  incoming: Requests | undefined;
+}
+
+export interface AcceptResponse {
+  user: User | undefined;
+}
+
+export interface AcceptPayload {
+  user: User | undefined;
+}
+
+export interface RejectResponse {
+  user: User | undefined;
+}
+
+export interface RejectPayload {
+  user: User | undefined;
+}
+
+export interface DeleteResponse {
+  user: User | undefined;
+}
+
+export interface DeletePayload {
+  user: User | undefined;
+}
+
+export interface CancelResponse {
+  user: User | undefined;
+}
+
+export interface CancelPayload {
+  user: User | undefined;
+}
+
+export interface UpdateFriendshipPayload {
+  event: FriendshipEventPayload | undefined;
+}
+
+export interface UpdateFriendshipResponse {
+  response?: { $case: "error"; error: FriendshipErrorCode } | { $case: "event"; event: FriendshipEventResponse };
+}
+
+export interface SubscribeFriendshipEventsUpdatesResponse {
+  events: FriendshipEventResponse[];
+}
+
+function createBaseFriendshipEventResponse(): FriendshipEventResponse {
+  return { body: undefined };
+}
+
+export const FriendshipEventResponse = {
+  encode(message: FriendshipEventResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    switch (message.body?.$case) {
+      case "request":
+        RequestResponse.encode(message.body.request, writer.uint32(10).fork()).ldelim();
+        break;
+      case "accept":
+        AcceptResponse.encode(message.body.accept, writer.uint32(18).fork()).ldelim();
+        break;
+      case "reject":
+        RejectResponse.encode(message.body.reject, writer.uint32(34).fork()).ldelim();
+        break;
+      case "delete":
+        DeleteResponse.encode(message.body.delete, writer.uint32(42).fork()).ldelim();
+        break;
+      case "cancel":
+        CancelResponse.encode(message.body.cancel, writer.uint32(50).fork()).ldelim();
+        break;
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): FriendshipEventResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFriendshipEventResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.body = { $case: "request", request: RequestResponse.decode(reader, reader.uint32()) };
+          break;
+        case 2:
+          message.body = { $case: "accept", accept: AcceptResponse.decode(reader, reader.uint32()) };
+          break;
+        case 4:
+          message.body = { $case: "reject", reject: RejectResponse.decode(reader, reader.uint32()) };
+          break;
+        case 5:
+          message.body = { $case: "delete", delete: DeleteResponse.decode(reader, reader.uint32()) };
+          break;
+        case 6:
+          message.body = { $case: "cancel", cancel: CancelResponse.decode(reader, reader.uint32()) };
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): FriendshipEventResponse {
+    return {
+      body: isSet(object.request)
+        ? { $case: "request", request: RequestResponse.fromJSON(object.request) }
+        : isSet(object.accept)
+        ? { $case: "accept", accept: AcceptResponse.fromJSON(object.accept) }
+        : isSet(object.reject)
+        ? { $case: "reject", reject: RejectResponse.fromJSON(object.reject) }
+        : isSet(object.delete)
+        ? { $case: "delete", delete: DeleteResponse.fromJSON(object.delete) }
+        : isSet(object.cancel)
+        ? { $case: "cancel", cancel: CancelResponse.fromJSON(object.cancel) }
+        : undefined,
+    };
+  },
+
+  toJSON(message: FriendshipEventResponse): unknown {
+    const obj: any = {};
+    message.body?.$case === "request" &&
+      (obj.request = message.body?.request ? RequestResponse.toJSON(message.body?.request) : undefined);
+    message.body?.$case === "accept" &&
+      (obj.accept = message.body?.accept ? AcceptResponse.toJSON(message.body?.accept) : undefined);
+    message.body?.$case === "reject" &&
+      (obj.reject = message.body?.reject ? RejectResponse.toJSON(message.body?.reject) : undefined);
+    message.body?.$case === "delete" &&
+      (obj.delete = message.body?.delete ? DeleteResponse.toJSON(message.body?.delete) : undefined);
+    message.body?.$case === "cancel" &&
+      (obj.cancel = message.body?.cancel ? CancelResponse.toJSON(message.body?.cancel) : undefined);
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<FriendshipEventResponse>, I>>(base?: I): FriendshipEventResponse {
+    return FriendshipEventResponse.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<FriendshipEventResponse>, I>>(object: I): FriendshipEventResponse {
+    const message = createBaseFriendshipEventResponse();
+    if (object.body?.$case === "request" && object.body?.request !== undefined && object.body?.request !== null) {
+      message.body = { $case: "request", request: RequestResponse.fromPartial(object.body.request) };
+    }
+    if (object.body?.$case === "accept" && object.body?.accept !== undefined && object.body?.accept !== null) {
+      message.body = { $case: "accept", accept: AcceptResponse.fromPartial(object.body.accept) };
+    }
+    if (object.body?.$case === "reject" && object.body?.reject !== undefined && object.body?.reject !== null) {
+      message.body = { $case: "reject", reject: RejectResponse.fromPartial(object.body.reject) };
+    }
+    if (object.body?.$case === "delete" && object.body?.delete !== undefined && object.body?.delete !== null) {
+      message.body = { $case: "delete", delete: DeleteResponse.fromPartial(object.body.delete) };
+    }
+    if (object.body?.$case === "cancel" && object.body?.cancel !== undefined && object.body?.cancel !== null) {
+      message.body = { $case: "cancel", cancel: CancelResponse.fromPartial(object.body.cancel) };
+    }
+    return message;
+  },
+};
+
+function createBaseFriendshipEventPayload(): FriendshipEventPayload {
+  return { body: undefined };
+}
+
+export const FriendshipEventPayload = {
+  encode(message: FriendshipEventPayload, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    switch (message.body?.$case) {
+      case "request":
+        RequestPayload.encode(message.body.request, writer.uint32(10).fork()).ldelim();
+        break;
+      case "accept":
+        AcceptPayload.encode(message.body.accept, writer.uint32(18).fork()).ldelim();
+        break;
+      case "reject":
+        RejectPayload.encode(message.body.reject, writer.uint32(34).fork()).ldelim();
+        break;
+      case "delete":
+        DeletePayload.encode(message.body.delete, writer.uint32(42).fork()).ldelim();
+        break;
+      case "cancel":
+        CancelPayload.encode(message.body.cancel, writer.uint32(50).fork()).ldelim();
+        break;
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): FriendshipEventPayload {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFriendshipEventPayload();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.body = { $case: "request", request: RequestPayload.decode(reader, reader.uint32()) };
+          break;
+        case 2:
+          message.body = { $case: "accept", accept: AcceptPayload.decode(reader, reader.uint32()) };
+          break;
+        case 4:
+          message.body = { $case: "reject", reject: RejectPayload.decode(reader, reader.uint32()) };
+          break;
+        case 5:
+          message.body = { $case: "delete", delete: DeletePayload.decode(reader, reader.uint32()) };
+          break;
+        case 6:
+          message.body = { $case: "cancel", cancel: CancelPayload.decode(reader, reader.uint32()) };
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): FriendshipEventPayload {
+    return {
+      body: isSet(object.request)
+        ? { $case: "request", request: RequestPayload.fromJSON(object.request) }
+        : isSet(object.accept)
+        ? { $case: "accept", accept: AcceptPayload.fromJSON(object.accept) }
+        : isSet(object.reject)
+        ? { $case: "reject", reject: RejectPayload.fromJSON(object.reject) }
+        : isSet(object.delete)
+        ? { $case: "delete", delete: DeletePayload.fromJSON(object.delete) }
+        : isSet(object.cancel)
+        ? { $case: "cancel", cancel: CancelPayload.fromJSON(object.cancel) }
+        : undefined,
+    };
+  },
+
+  toJSON(message: FriendshipEventPayload): unknown {
+    const obj: any = {};
+    message.body?.$case === "request" &&
+      (obj.request = message.body?.request ? RequestPayload.toJSON(message.body?.request) : undefined);
+    message.body?.$case === "accept" &&
+      (obj.accept = message.body?.accept ? AcceptPayload.toJSON(message.body?.accept) : undefined);
+    message.body?.$case === "reject" &&
+      (obj.reject = message.body?.reject ? RejectPayload.toJSON(message.body?.reject) : undefined);
+    message.body?.$case === "delete" &&
+      (obj.delete = message.body?.delete ? DeletePayload.toJSON(message.body?.delete) : undefined);
+    message.body?.$case === "cancel" &&
+      (obj.cancel = message.body?.cancel ? CancelPayload.toJSON(message.body?.cancel) : undefined);
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<FriendshipEventPayload>, I>>(base?: I): FriendshipEventPayload {
+    return FriendshipEventPayload.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<FriendshipEventPayload>, I>>(object: I): FriendshipEventPayload {
+    const message = createBaseFriendshipEventPayload();
+    if (object.body?.$case === "request" && object.body?.request !== undefined && object.body?.request !== null) {
+      message.body = { $case: "request", request: RequestPayload.fromPartial(object.body.request) };
+    }
+    if (object.body?.$case === "accept" && object.body?.accept !== undefined && object.body?.accept !== null) {
+      message.body = { $case: "accept", accept: AcceptPayload.fromPartial(object.body.accept) };
+    }
+    if (object.body?.$case === "reject" && object.body?.reject !== undefined && object.body?.reject !== null) {
+      message.body = { $case: "reject", reject: RejectPayload.fromPartial(object.body.reject) };
+    }
+    if (object.body?.$case === "delete" && object.body?.delete !== undefined && object.body?.delete !== null) {
+      message.body = { $case: "delete", delete: DeletePayload.fromPartial(object.body.delete) };
+    }
+    if (object.body?.$case === "cancel" && object.body?.cancel !== undefined && object.body?.cancel !== null) {
+      message.body = { $case: "cancel", cancel: CancelPayload.fromPartial(object.body.cancel) };
+    }
+    return message;
+  },
+};
+
+function createBaseUser(): User {
+  return { address: "" };
+}
+
+export const User = {
+  encode(message: User, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): User {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUser();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): User {
+    return { address: isSet(object.address) ? String(object.address) : "" };
+  },
+
+  toJSON(message: User): unknown {
+    const obj: any = {};
+    message.address !== undefined && (obj.address = message.address);
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<User>, I>>(base?: I): User {
+    return User.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<User>, I>>(object: I): User {
+    const message = createBaseUser();
+    message.address = object.address ?? "";
+    return message;
+  },
+};
+
+function createBaseUsers(): Users {
+  return { users: [] };
+}
+
+export const Users = {
+  encode(message: Users, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.users) {
+      User.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Users {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUsers();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.users.push(User.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Users {
+    return { users: Array.isArray(object?.users) ? object.users.map((e: any) => User.fromJSON(e)) : [] };
+  },
+
+  toJSON(message: Users): unknown {
+    const obj: any = {};
+    if (message.users) {
+      obj.users = message.users.map((e) => e ? User.toJSON(e) : undefined);
+    } else {
+      obj.users = [];
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Users>, I>>(base?: I): Users {
+    return Users.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<Users>, I>>(object: I): Users {
+    const message = createBaseUsers();
+    message.users = object.users?.map((e) => User.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseRequestResponse(): RequestResponse {
+  return { user: undefined, createdAt: 0, message: undefined };
+}
+
+export const RequestResponse = {
+  encode(message: RequestResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.user !== undefined) {
+      User.encode(message.user, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.createdAt !== 0) {
+      writer.uint32(16).int64(message.createdAt);
+    }
+    if (message.message !== undefined) {
+      writer.uint32(26).string(message.message);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): RequestResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRequestResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.user = User.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.createdAt = longToNumber(reader.int64() as Long);
+          break;
+        case 3:
+          message.message = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): RequestResponse {
+    return {
+      user: isSet(object.user) ? User.fromJSON(object.user) : undefined,
+      createdAt: isSet(object.createdAt) ? Number(object.createdAt) : 0,
+      message: isSet(object.message) ? String(object.message) : undefined,
+    };
+  },
+
+  toJSON(message: RequestResponse): unknown {
+    const obj: any = {};
+    message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
+    message.createdAt !== undefined && (obj.createdAt = Math.round(message.createdAt));
+    message.message !== undefined && (obj.message = message.message);
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<RequestResponse>, I>>(base?: I): RequestResponse {
+    return RequestResponse.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<RequestResponse>, I>>(object: I): RequestResponse {
+    const message = createBaseRequestResponse();
+    message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
+    message.createdAt = object.createdAt ?? 0;
+    message.message = object.message ?? undefined;
+    return message;
+  },
+};
+
+function createBaseRequestPayload(): RequestPayload {
+  return { user: undefined, message: undefined };
+}
+
+export const RequestPayload = {
+  encode(message: RequestPayload, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.user !== undefined) {
+      User.encode(message.user, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.message !== undefined) {
+      writer.uint32(26).string(message.message);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): RequestPayload {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRequestPayload();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.user = User.decode(reader, reader.uint32());
+          break;
+        case 3:
+          message.message = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): RequestPayload {
+    return {
+      user: isSet(object.user) ? User.fromJSON(object.user) : undefined,
+      message: isSet(object.message) ? String(object.message) : undefined,
+    };
+  },
+
+  toJSON(message: RequestPayload): unknown {
+    const obj: any = {};
+    message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
+    message.message !== undefined && (obj.message = message.message);
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<RequestPayload>, I>>(base?: I): RequestPayload {
+    return RequestPayload.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<RequestPayload>, I>>(object: I): RequestPayload {
+    const message = createBaseRequestPayload();
+    message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
+    message.message = object.message ?? undefined;
+    return message;
+  },
+};
+
+function createBaseRequests(): Requests {
+  return { total: 0, items: [] };
+}
+
+export const Requests = {
+  encode(message: Requests, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.total !== 0) {
+      writer.uint32(8).int64(message.total);
+    }
+    for (const v of message.items) {
+      RequestResponse.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Requests {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRequests();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.total = longToNumber(reader.int64() as Long);
+          break;
+        case 2:
+          message.items.push(RequestResponse.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Requests {
+    return {
+      total: isSet(object.total) ? Number(object.total) : 0,
+      items: Array.isArray(object?.items) ? object.items.map((e: any) => RequestResponse.fromJSON(e)) : [],
+    };
+  },
+
+  toJSON(message: Requests): unknown {
+    const obj: any = {};
+    message.total !== undefined && (obj.total = Math.round(message.total));
+    if (message.items) {
+      obj.items = message.items.map((e) => e ? RequestResponse.toJSON(e) : undefined);
+    } else {
+      obj.items = [];
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Requests>, I>>(base?: I): Requests {
+    return Requests.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<Requests>, I>>(object: I): Requests {
+    const message = createBaseRequests();
+    message.total = object.total ?? 0;
+    message.items = object.items?.map((e) => RequestResponse.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseRequestEvents(): RequestEvents {
+  return { outgoing: undefined, incoming: undefined };
+}
+
+export const RequestEvents = {
+  encode(message: RequestEvents, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.outgoing !== undefined) {
+      Requests.encode(message.outgoing, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.incoming !== undefined) {
+      Requests.encode(message.incoming, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): RequestEvents {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRequestEvents();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.outgoing = Requests.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.incoming = Requests.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): RequestEvents {
+    return {
+      outgoing: isSet(object.outgoing) ? Requests.fromJSON(object.outgoing) : undefined,
+      incoming: isSet(object.incoming) ? Requests.fromJSON(object.incoming) : undefined,
+    };
+  },
+
+  toJSON(message: RequestEvents): unknown {
+    const obj: any = {};
+    message.outgoing !== undefined && (obj.outgoing = message.outgoing ? Requests.toJSON(message.outgoing) : undefined);
+    message.incoming !== undefined && (obj.incoming = message.incoming ? Requests.toJSON(message.incoming) : undefined);
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<RequestEvents>, I>>(base?: I): RequestEvents {
+    return RequestEvents.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<RequestEvents>, I>>(object: I): RequestEvents {
+    const message = createBaseRequestEvents();
+    message.outgoing = (object.outgoing !== undefined && object.outgoing !== null)
+      ? Requests.fromPartial(object.outgoing)
+      : undefined;
+    message.incoming = (object.incoming !== undefined && object.incoming !== null)
+      ? Requests.fromPartial(object.incoming)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseAcceptResponse(): AcceptResponse {
+  return { user: undefined };
+}
+
+export const AcceptResponse = {
+  encode(message: AcceptResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.user !== undefined) {
+      User.encode(message.user, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): AcceptResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAcceptResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.user = User.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): AcceptResponse {
+    return { user: isSet(object.user) ? User.fromJSON(object.user) : undefined };
+  },
+
+  toJSON(message: AcceptResponse): unknown {
+    const obj: any = {};
+    message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<AcceptResponse>, I>>(base?: I): AcceptResponse {
+    return AcceptResponse.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<AcceptResponse>, I>>(object: I): AcceptResponse {
+    const message = createBaseAcceptResponse();
+    message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
+    return message;
+  },
+};
+
+function createBaseAcceptPayload(): AcceptPayload {
+  return { user: undefined };
+}
+
+export const AcceptPayload = {
+  encode(message: AcceptPayload, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.user !== undefined) {
+      User.encode(message.user, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): AcceptPayload {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAcceptPayload();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.user = User.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): AcceptPayload {
+    return { user: isSet(object.user) ? User.fromJSON(object.user) : undefined };
+  },
+
+  toJSON(message: AcceptPayload): unknown {
+    const obj: any = {};
+    message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<AcceptPayload>, I>>(base?: I): AcceptPayload {
+    return AcceptPayload.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<AcceptPayload>, I>>(object: I): AcceptPayload {
+    const message = createBaseAcceptPayload();
+    message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
+    return message;
+  },
+};
+
+function createBaseRejectResponse(): RejectResponse {
+  return { user: undefined };
+}
+
+export const RejectResponse = {
+  encode(message: RejectResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.user !== undefined) {
+      User.encode(message.user, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): RejectResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRejectResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.user = User.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): RejectResponse {
+    return { user: isSet(object.user) ? User.fromJSON(object.user) : undefined };
+  },
+
+  toJSON(message: RejectResponse): unknown {
+    const obj: any = {};
+    message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<RejectResponse>, I>>(base?: I): RejectResponse {
+    return RejectResponse.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<RejectResponse>, I>>(object: I): RejectResponse {
+    const message = createBaseRejectResponse();
+    message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
+    return message;
+  },
+};
+
+function createBaseRejectPayload(): RejectPayload {
+  return { user: undefined };
+}
+
+export const RejectPayload = {
+  encode(message: RejectPayload, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.user !== undefined) {
+      User.encode(message.user, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): RejectPayload {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRejectPayload();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.user = User.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): RejectPayload {
+    return { user: isSet(object.user) ? User.fromJSON(object.user) : undefined };
+  },
+
+  toJSON(message: RejectPayload): unknown {
+    const obj: any = {};
+    message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<RejectPayload>, I>>(base?: I): RejectPayload {
+    return RejectPayload.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<RejectPayload>, I>>(object: I): RejectPayload {
+    const message = createBaseRejectPayload();
+    message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
+    return message;
+  },
+};
+
+function createBaseDeleteResponse(): DeleteResponse {
+  return { user: undefined };
+}
+
+export const DeleteResponse = {
+  encode(message: DeleteResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.user !== undefined) {
+      User.encode(message.user, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): DeleteResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDeleteResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.user = User.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): DeleteResponse {
+    return { user: isSet(object.user) ? User.fromJSON(object.user) : undefined };
+  },
+
+  toJSON(message: DeleteResponse): unknown {
+    const obj: any = {};
+    message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<DeleteResponse>, I>>(base?: I): DeleteResponse {
+    return DeleteResponse.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<DeleteResponse>, I>>(object: I): DeleteResponse {
+    const message = createBaseDeleteResponse();
+    message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
+    return message;
+  },
+};
+
+function createBaseDeletePayload(): DeletePayload {
+  return { user: undefined };
+}
+
+export const DeletePayload = {
+  encode(message: DeletePayload, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.user !== undefined) {
+      User.encode(message.user, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): DeletePayload {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDeletePayload();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.user = User.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): DeletePayload {
+    return { user: isSet(object.user) ? User.fromJSON(object.user) : undefined };
+  },
+
+  toJSON(message: DeletePayload): unknown {
+    const obj: any = {};
+    message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<DeletePayload>, I>>(base?: I): DeletePayload {
+    return DeletePayload.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<DeletePayload>, I>>(object: I): DeletePayload {
+    const message = createBaseDeletePayload();
+    message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
+    return message;
+  },
+};
+
+function createBaseCancelResponse(): CancelResponse {
+  return { user: undefined };
+}
+
+export const CancelResponse = {
+  encode(message: CancelResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.user !== undefined) {
+      User.encode(message.user, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): CancelResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCancelResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.user = User.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): CancelResponse {
+    return { user: isSet(object.user) ? User.fromJSON(object.user) : undefined };
+  },
+
+  toJSON(message: CancelResponse): unknown {
+    const obj: any = {};
+    message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<CancelResponse>, I>>(base?: I): CancelResponse {
+    return CancelResponse.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<CancelResponse>, I>>(object: I): CancelResponse {
+    const message = createBaseCancelResponse();
+    message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
+    return message;
+  },
+};
+
+function createBaseCancelPayload(): CancelPayload {
+  return { user: undefined };
+}
+
+export const CancelPayload = {
+  encode(message: CancelPayload, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.user !== undefined) {
+      User.encode(message.user, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): CancelPayload {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCancelPayload();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.user = User.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): CancelPayload {
+    return { user: isSet(object.user) ? User.fromJSON(object.user) : undefined };
+  },
+
+  toJSON(message: CancelPayload): unknown {
+    const obj: any = {};
+    message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<CancelPayload>, I>>(base?: I): CancelPayload {
+    return CancelPayload.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<CancelPayload>, I>>(object: I): CancelPayload {
+    const message = createBaseCancelPayload();
+    message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
+    return message;
+  },
+};
+
+function createBaseUpdateFriendshipPayload(): UpdateFriendshipPayload {
+  return { event: undefined };
+}
+
+export const UpdateFriendshipPayload = {
+  encode(message: UpdateFriendshipPayload, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.event !== undefined) {
+      FriendshipEventPayload.encode(message.event, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): UpdateFriendshipPayload {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUpdateFriendshipPayload();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.event = FriendshipEventPayload.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): UpdateFriendshipPayload {
+    return { event: isSet(object.event) ? FriendshipEventPayload.fromJSON(object.event) : undefined };
+  },
+
+  toJSON(message: UpdateFriendshipPayload): unknown {
+    const obj: any = {};
+    message.event !== undefined &&
+      (obj.event = message.event ? FriendshipEventPayload.toJSON(message.event) : undefined);
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<UpdateFriendshipPayload>, I>>(base?: I): UpdateFriendshipPayload {
+    return UpdateFriendshipPayload.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<UpdateFriendshipPayload>, I>>(object: I): UpdateFriendshipPayload {
+    const message = createBaseUpdateFriendshipPayload();
+    message.event = (object.event !== undefined && object.event !== null)
+      ? FriendshipEventPayload.fromPartial(object.event)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseUpdateFriendshipResponse(): UpdateFriendshipResponse {
+  return { response: undefined };
+}
+
+export const UpdateFriendshipResponse = {
+  encode(message: UpdateFriendshipResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    switch (message.response?.$case) {
+      case "error":
+        writer.uint32(8).int32(message.response.error);
+        break;
+      case "event":
+        FriendshipEventResponse.encode(message.response.event, writer.uint32(18).fork()).ldelim();
+        break;
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): UpdateFriendshipResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUpdateFriendshipResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.response = { $case: "error", error: reader.int32() as any };
+          break;
+        case 2:
+          message.response = { $case: "event", event: FriendshipEventResponse.decode(reader, reader.uint32()) };
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): UpdateFriendshipResponse {
+    return {
+      response: isSet(object.error)
+        ? { $case: "error", error: friendshipErrorCodeFromJSON(object.error) }
+        : isSet(object.event)
+        ? { $case: "event", event: FriendshipEventResponse.fromJSON(object.event) }
+        : undefined,
+    };
+  },
+
+  toJSON(message: UpdateFriendshipResponse): unknown {
+    const obj: any = {};
+    message.response?.$case === "error" && (obj.error = message.response?.error !== undefined
+      ? friendshipErrorCodeToJSON(message.response?.error)
+      : undefined);
+    message.response?.$case === "event" &&
+      (obj.event = message.response?.event ? FriendshipEventResponse.toJSON(message.response?.event) : undefined);
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<UpdateFriendshipResponse>, I>>(base?: I): UpdateFriendshipResponse {
+    return UpdateFriendshipResponse.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<UpdateFriendshipResponse>, I>>(object: I): UpdateFriendshipResponse {
+    const message = createBaseUpdateFriendshipResponse();
+    if (object.response?.$case === "error" && object.response?.error !== undefined && object.response?.error !== null) {
+      message.response = { $case: "error", error: object.response.error };
+    }
+    if (object.response?.$case === "event" && object.response?.event !== undefined && object.response?.event !== null) {
+      message.response = { $case: "event", event: FriendshipEventResponse.fromPartial(object.response.event) };
+    }
+    return message;
+  },
+};
+
+function createBaseSubscribeFriendshipEventsUpdatesResponse(): SubscribeFriendshipEventsUpdatesResponse {
+  return { events: [] };
+}
+
+export const SubscribeFriendshipEventsUpdatesResponse = {
+  encode(message: SubscribeFriendshipEventsUpdatesResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.events) {
+      FriendshipEventResponse.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): SubscribeFriendshipEventsUpdatesResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSubscribeFriendshipEventsUpdatesResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.events.push(FriendshipEventResponse.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SubscribeFriendshipEventsUpdatesResponse {
+    return {
+      events: Array.isArray(object?.events) ? object.events.map((e: any) => FriendshipEventResponse.fromJSON(e)) : [],
+    };
+  },
+
+  toJSON(message: SubscribeFriendshipEventsUpdatesResponse): unknown {
+    const obj: any = {};
+    if (message.events) {
+      obj.events = message.events.map((e) => e ? FriendshipEventResponse.toJSON(e) : undefined);
+    } else {
+      obj.events = [];
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<SubscribeFriendshipEventsUpdatesResponse>, I>>(
+    base?: I,
+  ): SubscribeFriendshipEventsUpdatesResponse {
+    return SubscribeFriendshipEventsUpdatesResponse.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<SubscribeFriendshipEventsUpdatesResponse>, I>>(
+    object: I,
+  ): SubscribeFriendshipEventsUpdatesResponse {
+    const message = createBaseSubscribeFriendshipEventsUpdatesResponse();
+    message.events = object.events?.map((e) => FriendshipEventResponse.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+export type FriendshipsServiceDefinition = typeof FriendshipsServiceDefinition;
+export const FriendshipsServiceDefinition = {
+  name: "FriendshipsService",
+  fullName: "decentraland.social.friendships.FriendshipsService",
+  methods: {
+    /** Get the list of friends for the authenticated user */
+    getFriends: {
+      name: "GetFriends",
+      requestType: Empty,
+      requestStream: false,
+      responseType: Users,
+      responseStream: true,
+      options: {},
+    },
+    /** Get the list of request events for the authenticated user */
+    getRequestEvents: {
+      name: "GetRequestEvents",
+      requestType: Empty,
+      requestStream: false,
+      responseType: RequestEvents,
+      responseStream: false,
+      options: {},
+    },
+    /** Update friendship status: REQUEST, ACCEPT, REJECT, CANCEL, DELETE */
+    updateFriendshipEvent: {
+      name: "UpdateFriendshipEvent",
+      requestType: UpdateFriendshipPayload,
+      requestStream: false,
+      responseType: UpdateFriendshipResponse,
+      responseStream: false,
+      options: {},
+    },
+    /**
+     * Subscribe to updates of friendship status: REQUEST, ACCEPT, REJECT, CANCEL,
+     * DELETE
+     */
+    subscribeFriendshipEventsUpdates: {
+      name: "SubscribeFriendshipEventsUpdates",
+      requestType: Empty,
+      requestStream: false,
+      responseType: SubscribeFriendshipEventsUpdatesResponse,
+      responseStream: true,
+      options: {},
+    },
+  },
+} as const;
+
+declare var self: any | undefined;
+declare var window: any | undefined;
+declare var global: any | undefined;
+var tsProtoGlobalThis: any = (() => {
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  if (typeof self !== "undefined") {
+    return self;
+  }
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof global !== "undefined") {
+    return global;
+  }
+  throw "Unable to locate global object";
+})();
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { $case: string } ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { $case: T["$case"] }
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function longToNumber(long: Long): number {
+  if (long.gt(Number.MAX_SAFE_INTEGER)) {
+    throw new tsProtoGlobalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+  }
+  return long.toNumber();
+}
+
+if (_m0.util.Long !== Long) {
+  _m0.util.Long = Long as any;
+  _m0.configure();
+}
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}