@dcl/protocol 1.0.0-4982615619.commit-96dba07 → 1.0.0-4984397350.commit-6fe3e1b

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

@@ -4,70 +4,6 @@ import _m0 from "protobufjs/minimal";
 
 export const protobufPackage = "decentraland.social.friendships";
 
-export enum ServiceErrors {
-  /** UNKNOWN - proto3 requires that first value in enum have numeric value of 0 */
-  UNKNOWN = 0,
-  BAD_REQUEST = 400,
-  UNAUTHORIZED = 401,
-  FORBIDDEN = 403,
-  NOT_FOUND = 404,
-  TOO_MANY_REQUESTS = 429,
-  INTERNAL_SERVER_ERROR = 500,
-  UNRECOGNIZED = -1,
-}
-
-export function serviceErrorsFromJSON(object: any): ServiceErrors {
-  switch (object) {
-    case 0:
-    case "UNKNOWN":
-      return ServiceErrors.UNKNOWN;
-    case 400:
-    case "BAD_REQUEST":
-      return ServiceErrors.BAD_REQUEST;
-    case 401:
-    case "UNAUTHORIZED":
-      return ServiceErrors.UNAUTHORIZED;
-    case 403:
-    case "FORBIDDEN":
-      return ServiceErrors.FORBIDDEN;
-    case 404:
-    case "NOT_FOUND":
-      return ServiceErrors.NOT_FOUND;
-    case 429:
-    case "TOO_MANY_REQUESTS":
-      return ServiceErrors.TOO_MANY_REQUESTS;
-    case 500:
-    case "INTERNAL_SERVER_ERROR":
-      return ServiceErrors.INTERNAL_SERVER_ERROR;
-    case -1:
-    case "UNRECOGNIZED":
-    default:
-      return ServiceErrors.UNRECOGNIZED;
-  }
-}
-
-export function serviceErrorsToJSON(object: ServiceErrors): string {
-  switch (object) {
-    case ServiceErrors.UNKNOWN:
-      return "UNKNOWN";
-    case ServiceErrors.BAD_REQUEST:
-      return "BAD_REQUEST";
-    case ServiceErrors.UNAUTHORIZED:
-      return "UNAUTHORIZED";
-    case ServiceErrors.FORBIDDEN:
-      return "FORBIDDEN";
-    case ServiceErrors.NOT_FOUND:
-      return "NOT_FOUND";
-    case ServiceErrors.TOO_MANY_REQUESTS:
-      return "TOO_MANY_REQUESTS";
-    case ServiceErrors.INTERNAL_SERVER_ERROR:
-      return "INTERNAL_SERVER_ERROR";
-    case ServiceErrors.UNRECOGNIZED:
-    default:
-      return "UNRECOGNIZED";
-  }
-}
-
 /** This message is a response that is sent from the server to the client */
 export interface FriendshipEventResponse {
   body?:
@@ -78,6 +14,10 @@ export interface FriendshipEventResponse {
     | { $case: "cancel"; cancel: CancelResponse };
 }
 
+export interface FriendshipEventResponses {
+  responses: FriendshipEventResponse[];
+}
+
 export interface FriendshipEventPayload {
   body?:
     | { $case: "request"; request: RequestPayload }
@@ -161,17 +101,66 @@ export interface UpdateFriendshipPayload {
   authToken?: Payload | undefined;
 }
 
-export interface UpdateFriendshipResponse {
-  event: FriendshipEventResponse | undefined;
+export interface Payload {
+  /** For internal use only, subject to change. */
+  synapseToken?: string | undefined;
 }
 
-export interface SubscribeFriendshipEventsUpdatesResponse {
-  events: FriendshipEventResponse[];
+export interface BadRequestError {
+  message: string;
 }
 
-export interface Payload {
-  /** For internal use only, subject to change. */
-  synapseToken?: string | undefined;
+export interface UnauthorizedError {
+  message: string;
+}
+
+export interface ForbiddenError {
+  message: string;
+}
+
+export interface TooManyRequestsError {
+  message: string;
+}
+
+export interface InternalServerError {
+  message: string;
+}
+
+export interface UsersResponse {
+  response?:
+    | { $case: "users"; users: Users }
+    | { $case: "internalServerError"; internalServerError: InternalServerError }
+    | { $case: "unauthorizedError"; unauthorizedError: UnauthorizedError }
+    | { $case: "forbiddenError"; forbiddenError: ForbiddenError }
+    | { $case: "tooManyRequestsError"; tooManyRequestsError: TooManyRequestsError };
+}
+
+export interface RequestEventsResponse {
+  response?:
+    | { $case: "events"; events: RequestEvents }
+    | { $case: "internalServerError"; internalServerError: InternalServerError }
+    | { $case: "unauthorizedError"; unauthorizedError: UnauthorizedError }
+    | { $case: "forbiddenError"; forbiddenError: ForbiddenError }
+    | { $case: "tooManyRequestsError"; tooManyRequestsError: TooManyRequestsError };
+}
+
+export interface UpdateFriendshipResponse {
+  response?:
+    | { $case: "event"; event: FriendshipEventResponse }
+    | { $case: "internalServerError"; internalServerError: InternalServerError }
+    | { $case: "unauthorizedError"; unauthorizedError: UnauthorizedError }
+    | { $case: "forbiddenError"; forbiddenError: ForbiddenError }
+    | { $case: "tooManyRequestsError"; tooManyRequestsError: TooManyRequestsError }
+    | { $case: "badRequestError"; badRequestError: BadRequestError };
+}
+
+export interface SubscribeFriendshipEventsUpdatesResponse {
+  response?:
+    | { $case: "events"; events: FriendshipEventResponses }
+    | { $case: "internalServerError"; internalServerError: InternalServerError }
+    | { $case: "unauthorizedError"; unauthorizedError: UnauthorizedError }
+    | { $case: "forbiddenError"; forbiddenError: ForbiddenError }
+    | { $case: "tooManyRequestsError"; tooManyRequestsError: TooManyRequestsError };
 }
 
 function createBaseFriendshipEventResponse(): FriendshipEventResponse {
@@ -309,6 +298,74 @@ export namespace FriendshipEventResponse {
   }
 }
 
+function createBaseFriendshipEventResponses(): FriendshipEventResponses {
+  return { responses: [] };
+}
+
+export namespace FriendshipEventResponses {
+  export function encode(message: FriendshipEventResponses, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.responses) {
+      FriendshipEventResponse.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): FriendshipEventResponses {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFriendshipEventResponses();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.responses.push(FriendshipEventResponse.decode(reader, reader.uint32()));
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): FriendshipEventResponses {
+    return {
+      responses: Array.isArray(object?.responses)
+        ? object.responses.map((e: any) => FriendshipEventResponse.fromJSON(e))
+        : [],
+    };
+  }
+
+  export function toJSON(message: FriendshipEventResponses): unknown {
+    const obj: any = {};
+    if (message.responses) {
+      obj.responses = message.responses.map((e) => e ? FriendshipEventResponse.toJSON(e) : undefined);
+    } else {
+      obj.responses = [];
+    }
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<FriendshipEventResponses>, I>>(
+    base?: I,
+  ): FriendshipEventResponses {
+    return FriendshipEventResponses.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<FriendshipEventResponses>, I>>(
+    object: I,
+  ): FriendshipEventResponses {
+    const message = createBaseFriendshipEventResponses();
+    message.responses = object.responses?.map((e) => FriendshipEventResponse.fromPartial(e)) || [];
+    return message;
+  }
+}
+
 function createBaseFriendshipEventPayload(): FriendshipEventPayload {
   return { body: undefined };
 }
@@ -1392,22 +1449,22 @@ export namespace UpdateFriendshipPayload {
   }
 }
 
-function createBaseUpdateFriendshipResponse(): UpdateFriendshipResponse {
-  return { event: undefined };
+function createBasePayload(): Payload {
+  return { synapseToken: undefined };
 }
 
-export namespace UpdateFriendshipResponse {
-  export function encode(message: UpdateFriendshipResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.event !== undefined) {
-      FriendshipEventResponse.encode(message.event, writer.uint32(10).fork()).ldelim();
+export namespace Payload {
+  export function encode(message: Payload, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.synapseToken !== undefined) {
+      writer.uint32(10).string(message.synapseToken);
     }
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): UpdateFriendshipResponse {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): Payload {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseUpdateFriendshipResponse();
+    const message = createBasePayload();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -1416,7 +1473,7 @@ export namespace UpdateFriendshipResponse {
             break;
           }
 
-          message.event = FriendshipEventResponse.decode(reader, reader.uint32());
+          message.synapseToken = reader.string();
           continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
@@ -1427,53 +1484,43 @@ export namespace UpdateFriendshipResponse {
     return message;
   }
 
-  export function fromJSON(object: any): UpdateFriendshipResponse {
-    return { event: isSet(object.event) ? FriendshipEventResponse.fromJSON(object.event) : undefined };
+  export function fromJSON(object: any): Payload {
+    return { synapseToken: isSet(object.synapseToken) ? String(object.synapseToken) : undefined };
   }
 
-  export function toJSON(message: UpdateFriendshipResponse): unknown {
+  export function toJSON(message: Payload): unknown {
     const obj: any = {};
-    message.event !== undefined &&
-      (obj.event = message.event ? FriendshipEventResponse.toJSON(message.event) : undefined);
+    message.synapseToken !== undefined && (obj.synapseToken = message.synapseToken);
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<UpdateFriendshipResponse>, I>>(
-    base?: I,
-  ): UpdateFriendshipResponse {
-    return UpdateFriendshipResponse.fromPartial(base ?? {});
+  export function create<I extends Exact<DeepPartial<Payload>, I>>(base?: I): Payload {
+    return Payload.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<UpdateFriendshipResponse>, I>>(
-    object: I,
-  ): UpdateFriendshipResponse {
-    const message = createBaseUpdateFriendshipResponse();
-    message.event = (object.event !== undefined && object.event !== null)
-      ? FriendshipEventResponse.fromPartial(object.event)
-      : undefined;
+  export function fromPartial<I extends Exact<DeepPartial<Payload>, I>>(object: I): Payload {
+    const message = createBasePayload();
+    message.synapseToken = object.synapseToken ?? undefined;
     return message;
   }
 }
 
-function createBaseSubscribeFriendshipEventsUpdatesResponse(): SubscribeFriendshipEventsUpdatesResponse {
-  return { events: [] };
+function createBaseBadRequestError(): BadRequestError {
+  return { message: "" };
 }
 
-export namespace SubscribeFriendshipEventsUpdatesResponse {
-  export function 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();
+export namespace BadRequestError {
+  export function encode(message: BadRequestError, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.message !== "") {
+      writer.uint32(10).string(message.message);
     }
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): SubscribeFriendshipEventsUpdatesResponse {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): BadRequestError {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseSubscribeFriendshipEventsUpdatesResponse();
+    const message = createBaseBadRequestError();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -1482,7 +1529,7 @@ export namespace SubscribeFriendshipEventsUpdatesResponse {
             break;
           }
 
-          message.events.push(FriendshipEventResponse.decode(reader, reader.uint32()));
+          message.message = reader.string();
           continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
@@ -1493,53 +1540,99 @@ export namespace SubscribeFriendshipEventsUpdatesResponse {
     return message;
   }
 
-  export function fromJSON(object: any): SubscribeFriendshipEventsUpdatesResponse {
-    return {
-      events: Array.isArray(object?.events) ? object.events.map((e: any) => FriendshipEventResponse.fromJSON(e)) : [],
-    };
+  export function fromJSON(object: any): BadRequestError {
+    return { message: isSet(object.message) ? String(object.message) : "" };
   }
 
-  export function toJSON(message: SubscribeFriendshipEventsUpdatesResponse): unknown {
+  export function toJSON(message: BadRequestError): unknown {
     const obj: any = {};
-    if (message.events) {
-      obj.events = message.events.map((e) => e ? FriendshipEventResponse.toJSON(e) : undefined);
-    } else {
-      obj.events = [];
+    message.message !== undefined && (obj.message = message.message);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<BadRequestError>, I>>(base?: I): BadRequestError {
+    return BadRequestError.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<BadRequestError>, I>>(object: I): BadRequestError {
+    const message = createBaseBadRequestError();
+    message.message = object.message ?? "";
+    return message;
+  }
+}
+
+function createBaseUnauthorizedError(): UnauthorizedError {
+  return { message: "" };
+}
+
+export namespace UnauthorizedError {
+  export function encode(message: UnauthorizedError, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.message !== "") {
+      writer.uint32(10).string(message.message);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): UnauthorizedError {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUnauthorizedError();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.message = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
     }
+    return message;
+  }
+
+  export function fromJSON(object: any): UnauthorizedError {
+    return { message: isSet(object.message) ? String(object.message) : "" };
+  }
+
+  export function toJSON(message: UnauthorizedError): unknown {
+    const obj: any = {};
+    message.message !== undefined && (obj.message = message.message);
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<SubscribeFriendshipEventsUpdatesResponse>, I>>(
-    base?: I,
-  ): SubscribeFriendshipEventsUpdatesResponse {
-    return SubscribeFriendshipEventsUpdatesResponse.fromPartial(base ?? {});
+  export function create<I extends Exact<DeepPartial<UnauthorizedError>, I>>(base?: I): UnauthorizedError {
+    return UnauthorizedError.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<SubscribeFriendshipEventsUpdatesResponse>, I>>(
-    object: I,
-  ): SubscribeFriendshipEventsUpdatesResponse {
-    const message = createBaseSubscribeFriendshipEventsUpdatesResponse();
-    message.events = object.events?.map((e) => FriendshipEventResponse.fromPartial(e)) || [];
+  export function fromPartial<I extends Exact<DeepPartial<UnauthorizedError>, I>>(object: I): UnauthorizedError {
+    const message = createBaseUnauthorizedError();
+    message.message = object.message ?? "";
     return message;
   }
 }
 
-function createBasePayload(): Payload {
-  return { synapseToken: undefined };
+function createBaseForbiddenError(): ForbiddenError {
+  return { message: "" };
 }
 
-export namespace Payload {
-  export function encode(message: Payload, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.synapseToken !== undefined) {
-      writer.uint32(10).string(message.synapseToken);
+export namespace ForbiddenError {
+  export function encode(message: ForbiddenError, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.message !== "") {
+      writer.uint32(10).string(message.message);
     }
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): Payload {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): ForbiddenError {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBasePayload();
+    const message = createBaseForbiddenError();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -1548,7 +1641,7 @@ export namespace Payload {
             break;
           }
 
-          message.synapseToken = reader.string();
+          message.message = reader.string();
           continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
@@ -1559,23 +1652,929 @@ export namespace Payload {
     return message;
   }
 
-  export function fromJSON(object: any): Payload {
-    return { synapseToken: isSet(object.synapseToken) ? String(object.synapseToken) : undefined };
+  export function fromJSON(object: any): ForbiddenError {
+    return { message: isSet(object.message) ? String(object.message) : "" };
   }
 
-  export function toJSON(message: Payload): unknown {
+  export function toJSON(message: ForbiddenError): unknown {
     const obj: any = {};
-    message.synapseToken !== undefined && (obj.synapseToken = message.synapseToken);
+    message.message !== undefined && (obj.message = message.message);
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<Payload>, I>>(base?: I): Payload {
-    return Payload.fromPartial(base ?? {});
+  export function create<I extends Exact<DeepPartial<ForbiddenError>, I>>(base?: I): ForbiddenError {
+    return ForbiddenError.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<Payload>, I>>(object: I): Payload {
-    const message = createBasePayload();
-    message.synapseToken = object.synapseToken ?? undefined;
+  export function fromPartial<I extends Exact<DeepPartial<ForbiddenError>, I>>(object: I): ForbiddenError {
+    const message = createBaseForbiddenError();
+    message.message = object.message ?? "";
+    return message;
+  }
+}
+
+function createBaseTooManyRequestsError(): TooManyRequestsError {
+  return { message: "" };
+}
+
+export namespace TooManyRequestsError {
+  export function encode(message: TooManyRequestsError, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.message !== "") {
+      writer.uint32(10).string(message.message);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): TooManyRequestsError {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTooManyRequestsError();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.message = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): TooManyRequestsError {
+    return { message: isSet(object.message) ? String(object.message) : "" };
+  }
+
+  export function toJSON(message: TooManyRequestsError): unknown {
+    const obj: any = {};
+    message.message !== undefined && (obj.message = message.message);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<TooManyRequestsError>, I>>(base?: I): TooManyRequestsError {
+    return TooManyRequestsError.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<TooManyRequestsError>, I>>(object: I): TooManyRequestsError {
+    const message = createBaseTooManyRequestsError();
+    message.message = object.message ?? "";
+    return message;
+  }
+}
+
+function createBaseInternalServerError(): InternalServerError {
+  return { message: "" };
+}
+
+export namespace InternalServerError {
+  export function encode(message: InternalServerError, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.message !== "") {
+      writer.uint32(10).string(message.message);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): InternalServerError {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseInternalServerError();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.message = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): InternalServerError {
+    return { message: isSet(object.message) ? String(object.message) : "" };
+  }
+
+  export function toJSON(message: InternalServerError): unknown {
+    const obj: any = {};
+    message.message !== undefined && (obj.message = message.message);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<InternalServerError>, I>>(base?: I): InternalServerError {
+    return InternalServerError.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<InternalServerError>, I>>(object: I): InternalServerError {
+    const message = createBaseInternalServerError();
+    message.message = object.message ?? "";
+    return message;
+  }
+}
+
+function createBaseUsersResponse(): UsersResponse {
+  return { response: undefined };
+}
+
+export namespace UsersResponse {
+  export function encode(message: UsersResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    switch (message.response?.$case) {
+      case "users":
+        Users.encode(message.response.users, writer.uint32(10).fork()).ldelim();
+        break;
+      case "internalServerError":
+        InternalServerError.encode(message.response.internalServerError, writer.uint32(18).fork()).ldelim();
+        break;
+      case "unauthorizedError":
+        UnauthorizedError.encode(message.response.unauthorizedError, writer.uint32(26).fork()).ldelim();
+        break;
+      case "forbiddenError":
+        ForbiddenError.encode(message.response.forbiddenError, writer.uint32(34).fork()).ldelim();
+        break;
+      case "tooManyRequestsError":
+        TooManyRequestsError.encode(message.response.tooManyRequestsError, writer.uint32(42).fork()).ldelim();
+        break;
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): UsersResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUsersResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.response = { $case: "users", users: Users.decode(reader, reader.uint32()) };
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.response = {
+            $case: "internalServerError",
+            internalServerError: InternalServerError.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.response = {
+            $case: "unauthorizedError",
+            unauthorizedError: UnauthorizedError.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.response = {
+            $case: "forbiddenError",
+            forbiddenError: ForbiddenError.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.response = {
+            $case: "tooManyRequestsError",
+            tooManyRequestsError: TooManyRequestsError.decode(reader, reader.uint32()),
+          };
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): UsersResponse {
+    return {
+      response: isSet(object.users)
+        ? { $case: "users", users: Users.fromJSON(object.users) }
+        : isSet(object.internalServerError)
+        ? {
+          $case: "internalServerError",
+          internalServerError: InternalServerError.fromJSON(object.internalServerError),
+        }
+        : isSet(object.unauthorizedError)
+        ? { $case: "unauthorizedError", unauthorizedError: UnauthorizedError.fromJSON(object.unauthorizedError) }
+        : isSet(object.forbiddenError)
+        ? { $case: "forbiddenError", forbiddenError: ForbiddenError.fromJSON(object.forbiddenError) }
+        : isSet(object.tooManyRequestsError)
+        ? {
+          $case: "tooManyRequestsError",
+          tooManyRequestsError: TooManyRequestsError.fromJSON(object.tooManyRequestsError),
+        }
+        : undefined,
+    };
+  }
+
+  export function toJSON(message: UsersResponse): unknown {
+    const obj: any = {};
+    message.response?.$case === "users" &&
+      (obj.users = message.response?.users ? Users.toJSON(message.response?.users) : undefined);
+    message.response?.$case === "internalServerError" &&
+      (obj.internalServerError = message.response?.internalServerError
+        ? InternalServerError.toJSON(message.response?.internalServerError)
+        : undefined);
+    message.response?.$case === "unauthorizedError" &&
+      (obj.unauthorizedError = message.response?.unauthorizedError
+        ? UnauthorizedError.toJSON(message.response?.unauthorizedError)
+        : undefined);
+    message.response?.$case === "forbiddenError" &&
+      (obj.forbiddenError = message.response?.forbiddenError
+        ? ForbiddenError.toJSON(message.response?.forbiddenError)
+        : undefined);
+    message.response?.$case === "tooManyRequestsError" &&
+      (obj.tooManyRequestsError = message.response?.tooManyRequestsError
+        ? TooManyRequestsError.toJSON(message.response?.tooManyRequestsError)
+        : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<UsersResponse>, I>>(base?: I): UsersResponse {
+    return UsersResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<UsersResponse>, I>>(object: I): UsersResponse {
+    const message = createBaseUsersResponse();
+    if (object.response?.$case === "users" && object.response?.users !== undefined && object.response?.users !== null) {
+      message.response = { $case: "users", users: Users.fromPartial(object.response.users) };
+    }
+    if (
+      object.response?.$case === "internalServerError" &&
+      object.response?.internalServerError !== undefined &&
+      object.response?.internalServerError !== null
+    ) {
+      message.response = {
+        $case: "internalServerError",
+        internalServerError: InternalServerError.fromPartial(object.response.internalServerError),
+      };
+    }
+    if (
+      object.response?.$case === "unauthorizedError" &&
+      object.response?.unauthorizedError !== undefined &&
+      object.response?.unauthorizedError !== null
+    ) {
+      message.response = {
+        $case: "unauthorizedError",
+        unauthorizedError: UnauthorizedError.fromPartial(object.response.unauthorizedError),
+      };
+    }
+    if (
+      object.response?.$case === "forbiddenError" &&
+      object.response?.forbiddenError !== undefined &&
+      object.response?.forbiddenError !== null
+    ) {
+      message.response = {
+        $case: "forbiddenError",
+        forbiddenError: ForbiddenError.fromPartial(object.response.forbiddenError),
+      };
+    }
+    if (
+      object.response?.$case === "tooManyRequestsError" &&
+      object.response?.tooManyRequestsError !== undefined &&
+      object.response?.tooManyRequestsError !== null
+    ) {
+      message.response = {
+        $case: "tooManyRequestsError",
+        tooManyRequestsError: TooManyRequestsError.fromPartial(object.response.tooManyRequestsError),
+      };
+    }
+    return message;
+  }
+}
+
+function createBaseRequestEventsResponse(): RequestEventsResponse {
+  return { response: undefined };
+}
+
+export namespace RequestEventsResponse {
+  export function encode(message: RequestEventsResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    switch (message.response?.$case) {
+      case "events":
+        RequestEvents.encode(message.response.events, writer.uint32(10).fork()).ldelim();
+        break;
+      case "internalServerError":
+        InternalServerError.encode(message.response.internalServerError, writer.uint32(18).fork()).ldelim();
+        break;
+      case "unauthorizedError":
+        UnauthorizedError.encode(message.response.unauthorizedError, writer.uint32(26).fork()).ldelim();
+        break;
+      case "forbiddenError":
+        ForbiddenError.encode(message.response.forbiddenError, writer.uint32(34).fork()).ldelim();
+        break;
+      case "tooManyRequestsError":
+        TooManyRequestsError.encode(message.response.tooManyRequestsError, writer.uint32(42).fork()).ldelim();
+        break;
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): RequestEventsResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRequestEventsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.response = { $case: "events", events: RequestEvents.decode(reader, reader.uint32()) };
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.response = {
+            $case: "internalServerError",
+            internalServerError: InternalServerError.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.response = {
+            $case: "unauthorizedError",
+            unauthorizedError: UnauthorizedError.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.response = {
+            $case: "forbiddenError",
+            forbiddenError: ForbiddenError.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.response = {
+            $case: "tooManyRequestsError",
+            tooManyRequestsError: TooManyRequestsError.decode(reader, reader.uint32()),
+          };
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): RequestEventsResponse {
+    return {
+      response: isSet(object.events)
+        ? { $case: "events", events: RequestEvents.fromJSON(object.events) }
+        : isSet(object.internalServerError)
+        ? {
+          $case: "internalServerError",
+          internalServerError: InternalServerError.fromJSON(object.internalServerError),
+        }
+        : isSet(object.unauthorizedError)
+        ? { $case: "unauthorizedError", unauthorizedError: UnauthorizedError.fromJSON(object.unauthorizedError) }
+        : isSet(object.forbiddenError)
+        ? { $case: "forbiddenError", forbiddenError: ForbiddenError.fromJSON(object.forbiddenError) }
+        : isSet(object.tooManyRequestsError)
+        ? {
+          $case: "tooManyRequestsError",
+          tooManyRequestsError: TooManyRequestsError.fromJSON(object.tooManyRequestsError),
+        }
+        : undefined,
+    };
+  }
+
+  export function toJSON(message: RequestEventsResponse): unknown {
+    const obj: any = {};
+    message.response?.$case === "events" &&
+      (obj.events = message.response?.events ? RequestEvents.toJSON(message.response?.events) : undefined);
+    message.response?.$case === "internalServerError" &&
+      (obj.internalServerError = message.response?.internalServerError
+        ? InternalServerError.toJSON(message.response?.internalServerError)
+        : undefined);
+    message.response?.$case === "unauthorizedError" &&
+      (obj.unauthorizedError = message.response?.unauthorizedError
+        ? UnauthorizedError.toJSON(message.response?.unauthorizedError)
+        : undefined);
+    message.response?.$case === "forbiddenError" &&
+      (obj.forbiddenError = message.response?.forbiddenError
+        ? ForbiddenError.toJSON(message.response?.forbiddenError)
+        : undefined);
+    message.response?.$case === "tooManyRequestsError" &&
+      (obj.tooManyRequestsError = message.response?.tooManyRequestsError
+        ? TooManyRequestsError.toJSON(message.response?.tooManyRequestsError)
+        : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<RequestEventsResponse>, I>>(base?: I): RequestEventsResponse {
+    return RequestEventsResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<RequestEventsResponse>, I>>(
+    object: I,
+  ): RequestEventsResponse {
+    const message = createBaseRequestEventsResponse();
+    if (
+      object.response?.$case === "events" && object.response?.events !== undefined && object.response?.events !== null
+    ) {
+      message.response = { $case: "events", events: RequestEvents.fromPartial(object.response.events) };
+    }
+    if (
+      object.response?.$case === "internalServerError" &&
+      object.response?.internalServerError !== undefined &&
+      object.response?.internalServerError !== null
+    ) {
+      message.response = {
+        $case: "internalServerError",
+        internalServerError: InternalServerError.fromPartial(object.response.internalServerError),
+      };
+    }
+    if (
+      object.response?.$case === "unauthorizedError" &&
+      object.response?.unauthorizedError !== undefined &&
+      object.response?.unauthorizedError !== null
+    ) {
+      message.response = {
+        $case: "unauthorizedError",
+        unauthorizedError: UnauthorizedError.fromPartial(object.response.unauthorizedError),
+      };
+    }
+    if (
+      object.response?.$case === "forbiddenError" &&
+      object.response?.forbiddenError !== undefined &&
+      object.response?.forbiddenError !== null
+    ) {
+      message.response = {
+        $case: "forbiddenError",
+        forbiddenError: ForbiddenError.fromPartial(object.response.forbiddenError),
+      };
+    }
+    if (
+      object.response?.$case === "tooManyRequestsError" &&
+      object.response?.tooManyRequestsError !== undefined &&
+      object.response?.tooManyRequestsError !== null
+    ) {
+      message.response = {
+        $case: "tooManyRequestsError",
+        tooManyRequestsError: TooManyRequestsError.fromPartial(object.response.tooManyRequestsError),
+      };
+    }
+    return message;
+  }
+}
+
+function createBaseUpdateFriendshipResponse(): UpdateFriendshipResponse {
+  return { response: undefined };
+}
+
+export namespace UpdateFriendshipResponse {
+  export function encode(message: UpdateFriendshipResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    switch (message.response?.$case) {
+      case "event":
+        FriendshipEventResponse.encode(message.response.event, writer.uint32(10).fork()).ldelim();
+        break;
+      case "internalServerError":
+        InternalServerError.encode(message.response.internalServerError, writer.uint32(18).fork()).ldelim();
+        break;
+      case "unauthorizedError":
+        UnauthorizedError.encode(message.response.unauthorizedError, writer.uint32(26).fork()).ldelim();
+        break;
+      case "forbiddenError":
+        ForbiddenError.encode(message.response.forbiddenError, writer.uint32(34).fork()).ldelim();
+        break;
+      case "tooManyRequestsError":
+        TooManyRequestsError.encode(message.response.tooManyRequestsError, writer.uint32(42).fork()).ldelim();
+        break;
+      case "badRequestError":
+        BadRequestError.encode(message.response.badRequestError, writer.uint32(50).fork()).ldelim();
+        break;
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): UpdateFriendshipResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(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:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.response = { $case: "event", event: FriendshipEventResponse.decode(reader, reader.uint32()) };
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.response = {
+            $case: "internalServerError",
+            internalServerError: InternalServerError.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.response = {
+            $case: "unauthorizedError",
+            unauthorizedError: UnauthorizedError.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.response = {
+            $case: "forbiddenError",
+            forbiddenError: ForbiddenError.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.response = {
+            $case: "tooManyRequestsError",
+            tooManyRequestsError: TooManyRequestsError.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 6:
+          if (tag !== 50) {
+            break;
+          }
+
+          message.response = {
+            $case: "badRequestError",
+            badRequestError: BadRequestError.decode(reader, reader.uint32()),
+          };
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): UpdateFriendshipResponse {
+    return {
+      response: isSet(object.event)
+        ? { $case: "event", event: FriendshipEventResponse.fromJSON(object.event) }
+        : isSet(object.internalServerError)
+        ? {
+          $case: "internalServerError",
+          internalServerError: InternalServerError.fromJSON(object.internalServerError),
+        }
+        : isSet(object.unauthorizedError)
+        ? { $case: "unauthorizedError", unauthorizedError: UnauthorizedError.fromJSON(object.unauthorizedError) }
+        : isSet(object.forbiddenError)
+        ? { $case: "forbiddenError", forbiddenError: ForbiddenError.fromJSON(object.forbiddenError) }
+        : isSet(object.tooManyRequestsError)
+        ? {
+          $case: "tooManyRequestsError",
+          tooManyRequestsError: TooManyRequestsError.fromJSON(object.tooManyRequestsError),
+        }
+        : isSet(object.badRequestError)
+        ? { $case: "badRequestError", badRequestError: BadRequestError.fromJSON(object.badRequestError) }
+        : undefined,
+    };
+  }
+
+  export function toJSON(message: UpdateFriendshipResponse): unknown {
+    const obj: any = {};
+    message.response?.$case === "event" &&
+      (obj.event = message.response?.event ? FriendshipEventResponse.toJSON(message.response?.event) : undefined);
+    message.response?.$case === "internalServerError" &&
+      (obj.internalServerError = message.response?.internalServerError
+        ? InternalServerError.toJSON(message.response?.internalServerError)
+        : undefined);
+    message.response?.$case === "unauthorizedError" &&
+      (obj.unauthorizedError = message.response?.unauthorizedError
+        ? UnauthorizedError.toJSON(message.response?.unauthorizedError)
+        : undefined);
+    message.response?.$case === "forbiddenError" &&
+      (obj.forbiddenError = message.response?.forbiddenError
+        ? ForbiddenError.toJSON(message.response?.forbiddenError)
+        : undefined);
+    message.response?.$case === "tooManyRequestsError" &&
+      (obj.tooManyRequestsError = message.response?.tooManyRequestsError
+        ? TooManyRequestsError.toJSON(message.response?.tooManyRequestsError)
+        : undefined);
+    message.response?.$case === "badRequestError" &&
+      (obj.badRequestError = message.response?.badRequestError
+        ? BadRequestError.toJSON(message.response?.badRequestError)
+        : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<UpdateFriendshipResponse>, I>>(
+    base?: I,
+  ): UpdateFriendshipResponse {
+    return UpdateFriendshipResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<UpdateFriendshipResponse>, I>>(
+    object: I,
+  ): UpdateFriendshipResponse {
+    const message = createBaseUpdateFriendshipResponse();
+    if (object.response?.$case === "event" && object.response?.event !== undefined && object.response?.event !== null) {
+      message.response = { $case: "event", event: FriendshipEventResponse.fromPartial(object.response.event) };
+    }
+    if (
+      object.response?.$case === "internalServerError" &&
+      object.response?.internalServerError !== undefined &&
+      object.response?.internalServerError !== null
+    ) {
+      message.response = {
+        $case: "internalServerError",
+        internalServerError: InternalServerError.fromPartial(object.response.internalServerError),
+      };
+    }
+    if (
+      object.response?.$case === "unauthorizedError" &&
+      object.response?.unauthorizedError !== undefined &&
+      object.response?.unauthorizedError !== null
+    ) {
+      message.response = {
+        $case: "unauthorizedError",
+        unauthorizedError: UnauthorizedError.fromPartial(object.response.unauthorizedError),
+      };
+    }
+    if (
+      object.response?.$case === "forbiddenError" &&
+      object.response?.forbiddenError !== undefined &&
+      object.response?.forbiddenError !== null
+    ) {
+      message.response = {
+        $case: "forbiddenError",
+        forbiddenError: ForbiddenError.fromPartial(object.response.forbiddenError),
+      };
+    }
+    if (
+      object.response?.$case === "tooManyRequestsError" &&
+      object.response?.tooManyRequestsError !== undefined &&
+      object.response?.tooManyRequestsError !== null
+    ) {
+      message.response = {
+        $case: "tooManyRequestsError",
+        tooManyRequestsError: TooManyRequestsError.fromPartial(object.response.tooManyRequestsError),
+      };
+    }
+    if (
+      object.response?.$case === "badRequestError" &&
+      object.response?.badRequestError !== undefined &&
+      object.response?.badRequestError !== null
+    ) {
+      message.response = {
+        $case: "badRequestError",
+        badRequestError: BadRequestError.fromPartial(object.response.badRequestError),
+      };
+    }
+    return message;
+  }
+}
+
+function createBaseSubscribeFriendshipEventsUpdatesResponse(): SubscribeFriendshipEventsUpdatesResponse {
+  return { response: undefined };
+}
+
+export namespace SubscribeFriendshipEventsUpdatesResponse {
+  export function encode(
+    message: SubscribeFriendshipEventsUpdatesResponse,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    switch (message.response?.$case) {
+      case "events":
+        FriendshipEventResponses.encode(message.response.events, writer.uint32(10).fork()).ldelim();
+        break;
+      case "internalServerError":
+        InternalServerError.encode(message.response.internalServerError, writer.uint32(18).fork()).ldelim();
+        break;
+      case "unauthorizedError":
+        UnauthorizedError.encode(message.response.unauthorizedError, writer.uint32(26).fork()).ldelim();
+        break;
+      case "forbiddenError":
+        ForbiddenError.encode(message.response.forbiddenError, writer.uint32(34).fork()).ldelim();
+        break;
+      case "tooManyRequestsError":
+        TooManyRequestsError.encode(message.response.tooManyRequestsError, writer.uint32(42).fork()).ldelim();
+        break;
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): SubscribeFriendshipEventsUpdatesResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(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:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.response = { $case: "events", events: FriendshipEventResponses.decode(reader, reader.uint32()) };
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.response = {
+            $case: "internalServerError",
+            internalServerError: InternalServerError.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.response = {
+            $case: "unauthorizedError",
+            unauthorizedError: UnauthorizedError.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.response = {
+            $case: "forbiddenError",
+            forbiddenError: ForbiddenError.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.response = {
+            $case: "tooManyRequestsError",
+            tooManyRequestsError: TooManyRequestsError.decode(reader, reader.uint32()),
+          };
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): SubscribeFriendshipEventsUpdatesResponse {
+    return {
+      response: isSet(object.events)
+        ? { $case: "events", events: FriendshipEventResponses.fromJSON(object.events) }
+        : isSet(object.internalServerError)
+        ? {
+          $case: "internalServerError",
+          internalServerError: InternalServerError.fromJSON(object.internalServerError),
+        }
+        : isSet(object.unauthorizedError)
+        ? { $case: "unauthorizedError", unauthorizedError: UnauthorizedError.fromJSON(object.unauthorizedError) }
+        : isSet(object.forbiddenError)
+        ? { $case: "forbiddenError", forbiddenError: ForbiddenError.fromJSON(object.forbiddenError) }
+        : isSet(object.tooManyRequestsError)
+        ? {
+          $case: "tooManyRequestsError",
+          tooManyRequestsError: TooManyRequestsError.fromJSON(object.tooManyRequestsError),
+        }
+        : undefined,
+    };
+  }
+
+  export function toJSON(message: SubscribeFriendshipEventsUpdatesResponse): unknown {
+    const obj: any = {};
+    message.response?.$case === "events" &&
+      (obj.events = message.response?.events ? FriendshipEventResponses.toJSON(message.response?.events) : undefined);
+    message.response?.$case === "internalServerError" &&
+      (obj.internalServerError = message.response?.internalServerError
+        ? InternalServerError.toJSON(message.response?.internalServerError)
+        : undefined);
+    message.response?.$case === "unauthorizedError" &&
+      (obj.unauthorizedError = message.response?.unauthorizedError
+        ? UnauthorizedError.toJSON(message.response?.unauthorizedError)
+        : undefined);
+    message.response?.$case === "forbiddenError" &&
+      (obj.forbiddenError = message.response?.forbiddenError
+        ? ForbiddenError.toJSON(message.response?.forbiddenError)
+        : undefined);
+    message.response?.$case === "tooManyRequestsError" &&
+      (obj.tooManyRequestsError = message.response?.tooManyRequestsError
+        ? TooManyRequestsError.toJSON(message.response?.tooManyRequestsError)
+        : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<SubscribeFriendshipEventsUpdatesResponse>, I>>(
+    base?: I,
+  ): SubscribeFriendshipEventsUpdatesResponse {
+    return SubscribeFriendshipEventsUpdatesResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<SubscribeFriendshipEventsUpdatesResponse>, I>>(
+    object: I,
+  ): SubscribeFriendshipEventsUpdatesResponse {
+    const message = createBaseSubscribeFriendshipEventsUpdatesResponse();
+    if (
+      object.response?.$case === "events" && object.response?.events !== undefined && object.response?.events !== null
+    ) {
+      message.response = { $case: "events", events: FriendshipEventResponses.fromPartial(object.response.events) };
+    }
+    if (
+      object.response?.$case === "internalServerError" &&
+      object.response?.internalServerError !== undefined &&
+      object.response?.internalServerError !== null
+    ) {
+      message.response = {
+        $case: "internalServerError",
+        internalServerError: InternalServerError.fromPartial(object.response.internalServerError),
+      };
+    }
+    if (
+      object.response?.$case === "unauthorizedError" &&
+      object.response?.unauthorizedError !== undefined &&
+      object.response?.unauthorizedError !== null
+    ) {
+      message.response = {
+        $case: "unauthorizedError",
+        unauthorizedError: UnauthorizedError.fromPartial(object.response.unauthorizedError),
+      };
+    }
+    if (
+      object.response?.$case === "forbiddenError" &&
+      object.response?.forbiddenError !== undefined &&
+      object.response?.forbiddenError !== null
+    ) {
+      message.response = {
+        $case: "forbiddenError",
+        forbiddenError: ForbiddenError.fromPartial(object.response.forbiddenError),
+      };
+    }
+    if (
+      object.response?.$case === "tooManyRequestsError" &&
+      object.response?.tooManyRequestsError !== undefined &&
+      object.response?.tooManyRequestsError !== null
+    ) {
+      message.response = {
+        $case: "tooManyRequestsError",
+        tooManyRequestsError: TooManyRequestsError.fromPartial(object.response.tooManyRequestsError),
+      };
+    }
     return message;
   }
 }
@@ -1590,7 +2589,7 @@ export const FriendshipsServiceDefinition = {
       name: "GetFriends",
       requestType: Payload,
       requestStream: false,
-      responseType: Users,
+      responseType: UsersResponse,
       responseStream: true,
       options: {},
     },
@@ -1599,7 +2598,7 @@ export const FriendshipsServiceDefinition = {
       name: "GetRequestEvents",
       requestType: Payload,
       requestStream: false,
-      responseType: RequestEvents,
+      responseType: RequestEventsResponse,
       responseStream: false,
       options: {},
     },
@@ -1612,10 +2611,7 @@ export const FriendshipsServiceDefinition = {
       responseStream: false,
       options: {},
     },
-    /**
-     * Subscribe to updates of friendship status: REQUEST, ACCEPT, REJECT, CANCEL,
-     * DELETE
-     */
+    /** Subscribe to updates of friendship status: REQUEST, ACCEPT, REJECT, CANCEL, DELETE */
     subscribeFriendshipEventsUpdates: {
       name: "SubscribeFriendshipEventsUpdates",
       requestType: Payload,