@dcl/protocol 1.0.0-13831858134.commit-4a5d023 → 1.0.0-13897190826.commit-195803d

package/out-ts/decentraland/social_service/v2/social_service_v2.gen.ts

@@ -52,6 +52,8 @@ export enum FriendshipStatus {
   REJECTED = 4,
   DELETED = 5,
   BLOCKED = 6,
+  NONE = 7,
+  BLOCKED_BY = 8,
   UNRECOGNIZED = -1,
 }
 
@@ -78,6 +80,12 @@ export function friendshipStatusFromJSON(object: any): FriendshipStatus {
     case 6:
     case "BLOCKED":
       return FriendshipStatus.BLOCKED;
+    case 7:
+    case "NONE":
+      return FriendshipStatus.NONE;
+    case 8:
+    case "BLOCKED_BY":
+      return FriendshipStatus.BLOCKED_BY;
     case -1:
     case "UNRECOGNIZED":
     default:
@@ -101,6 +109,10 @@ export function friendshipStatusToJSON(object: FriendshipStatus): string {
       return "DELETED";
     case FriendshipStatus.BLOCKED:
       return "BLOCKED";
+    case FriendshipStatus.NONE:
+      return "NONE";
+    case FriendshipStatus.BLOCKED_BY:
+      return "BLOCKED_BY";
     case FriendshipStatus.UNRECOGNIZED:
     default:
       return "UNRECOGNIZED";
@@ -109,9 +121,19 @@ export function friendshipStatusToJSON(object: FriendshipStatus): string {
 
 /** Errors */
 export interface InvalidFriendshipAction {
+  message?: string | undefined;
 }
 
 export interface InternalServerError {
+  message?: string | undefined;
+}
+
+export interface InvalidRequest {
+  message?: string | undefined;
+}
+
+export interface ProfileNotFound {
+  message?: string | undefined;
 }
 
 /** Types */
@@ -119,15 +141,31 @@ export interface User {
   address: string;
 }
 
+export interface FriendProfile {
+  address: string;
+  name: string;
+  hasClaimedName: boolean;
+  profilePictureUrl: string;
+}
+
+export interface BlockedUserProfile {
+  address: string;
+  name: string;
+  hasClaimedName: boolean;
+  profilePictureUrl: string;
+  blockedAt?: number | undefined;
+}
+
 export interface Pagination {
   limit: number;
   offset: number;
 }
 
 export interface FriendshipRequestResponse {
-  user: User | undefined;
+  friend: FriendProfile | undefined;
   createdAt: number;
   message?: string | undefined;
+  id: string;
 }
 
 export interface FriendshipRequests {
@@ -136,7 +174,6 @@ export interface FriendshipRequests {
 
 export interface GetFriendsPayload {
   pagination?: Pagination | undefined;
-  status?: ConnectivityStatus | undefined;
 }
 
 export interface GetFriendshipRequestsPayload {
@@ -184,8 +221,8 @@ export interface PaginatedResponse {
   page: number;
 }
 
-export interface PaginatedUsersResponse {
-  users: User[];
+export interface PaginatedFriendsProfilesResponse {
+  friends: FriendProfile[];
   paginationData: PaginatedResponse | undefined;
 }
 
@@ -208,18 +245,28 @@ export interface UpsertFriendshipResponse {
 export interface UpsertFriendshipResponse_Accepted {
   id: string;
   createdAt: number;
+  friend: FriendProfile | undefined;
+  message?: string | undefined;
 }
 
 export interface FriendshipUpdate {
   update?:
-    | { $case: "request"; request: FriendshipRequestResponse }
+    | { $case: "request"; request: FriendshipUpdate_RequestResponse }
     | { $case: "accept"; accept: FriendshipUpdate_AcceptResponse }
     | { $case: "reject"; reject: FriendshipUpdate_RejectResponse }
     | { $case: "delete"; delete: FriendshipUpdate_DeleteResponse }
     | { $case: "cancel"; cancel: FriendshipUpdate_CancelResponse }
+    | { $case: "block"; block: FriendshipUpdate_BlockResponse }
     | undefined;
 }
 
+export interface FriendshipUpdate_RequestResponse {
+  friend: FriendProfile | undefined;
+  createdAt: number;
+  message?: string | undefined;
+  id: string;
+}
+
 export interface FriendshipUpdate_AcceptResponse {
   user: User | undefined;
 }
@@ -236,6 +283,15 @@ export interface FriendshipUpdate_CancelResponse {
   user: User | undefined;
 }
 
+export interface FriendshipUpdate_BlockResponse {
+  user: User | undefined;
+}
+
+export interface FriendConnectivityUpdate {
+  friend: FriendProfile | undefined;
+  status: ConnectivityStatus;
+}
+
 export interface GetFriendshipStatusPayload {
   user: User | undefined;
 }
@@ -252,12 +308,68 @@ export interface GetFriendshipStatusResponse_Ok {
   message?: string | undefined;
 }
 
+export interface BlockUserPayload {
+  user: User | undefined;
+}
+
+export interface BlockUserResponse {
+  response?:
+    | { $case: "ok"; ok: BlockUserResponse_Ok }
+    | { $case: "internalServerError"; internalServerError: InternalServerError }
+    | { $case: "invalidRequest"; invalidRequest: InvalidRequest }
+    | { $case: "profileNotFound"; profileNotFound: ProfileNotFound }
+    | undefined;
+}
+
+export interface BlockUserResponse_Ok {
+  profile: BlockedUserProfile | undefined;
+}
+
+export interface UnblockUserPayload {
+  user: User | undefined;
+}
+
+export interface UnblockUserResponse {
+  response?:
+    | { $case: "ok"; ok: UnblockUserResponse_Ok }
+    | { $case: "internalServerError"; internalServerError: InternalServerError }
+    | { $case: "invalidRequest"; invalidRequest: InvalidRequest }
+    | { $case: "profileNotFound"; profileNotFound: ProfileNotFound }
+    | undefined;
+}
+
+export interface UnblockUserResponse_Ok {
+  profile: BlockedUserProfile | undefined;
+}
+
+export interface GetBlockedUsersPayload {
+  pagination?: Pagination | undefined;
+}
+
+export interface GetBlockedUsersResponse {
+  profiles: BlockedUserProfile[];
+  paginationData: PaginatedResponse | undefined;
+}
+
+export interface GetBlockingStatusResponse {
+  blockedUsers: string[];
+  blockedByUsers: string[];
+}
+
+export interface BlockUpdate {
+  address: string;
+  isBlocked: boolean;
+}
+
 function createBaseInvalidFriendshipAction(): InvalidFriendshipAction {
-  return {};
+  return { message: undefined };
 }
 
 export namespace InvalidFriendshipAction {
-  export function encode(_: InvalidFriendshipAction, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+  export function encode(message: InvalidFriendshipAction, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.message !== undefined) {
+      writer.uint32(10).string(message.message);
+    }
     return writer;
   }
 
@@ -268,6 +380,13 @@ export namespace InvalidFriendshipAction {
     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;
@@ -277,12 +396,13 @@ export namespace InvalidFriendshipAction {
     return message;
   }
 
-  export function fromJSON(_: any): InvalidFriendshipAction {
-    return {};
+  export function fromJSON(object: any): InvalidFriendshipAction {
+    return { message: isSet(object.message) ? String(object.message) : undefined };
   }
 
-  export function toJSON(_: InvalidFriendshipAction): unknown {
+  export function toJSON(message: InvalidFriendshipAction): unknown {
     const obj: any = {};
+    message.message !== undefined && (obj.message = message.message);
     return obj;
   }
 
@@ -290,18 +410,24 @@ export namespace InvalidFriendshipAction {
     return InvalidFriendshipAction.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<InvalidFriendshipAction>, I>>(_: I): InvalidFriendshipAction {
+  export function fromPartial<I extends Exact<DeepPartial<InvalidFriendshipAction>, I>>(
+    object: I,
+  ): InvalidFriendshipAction {
     const message = createBaseInvalidFriendshipAction();
+    message.message = object.message ?? undefined;
     return message;
   }
 }
 
 function createBaseInternalServerError(): InternalServerError {
-  return {};
+  return { message: undefined };
 }
 
 export namespace InternalServerError {
-  export function encode(_: InternalServerError, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+  export function encode(message: InternalServerError, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.message !== undefined) {
+      writer.uint32(10).string(message.message);
+    }
     return writer;
   }
 
@@ -312,6 +438,13 @@ export namespace InternalServerError {
     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;
@@ -321,12 +454,13 @@ export namespace InternalServerError {
     return message;
   }
 
-  export function fromJSON(_: any): InternalServerError {
-    return {};
+  export function fromJSON(object: any): InternalServerError {
+    return { message: isSet(object.message) ? String(object.message) : undefined };
   }
 
-  export function toJSON(_: InternalServerError): unknown {
+  export function toJSON(message: InternalServerError): unknown {
     const obj: any = {};
+    message.message !== undefined && (obj.message = message.message);
     return obj;
   }
 
@@ -334,28 +468,29 @@ export namespace InternalServerError {
     return InternalServerError.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<InternalServerError>, I>>(_: I): InternalServerError {
+  export function fromPartial<I extends Exact<DeepPartial<InternalServerError>, I>>(object: I): InternalServerError {
     const message = createBaseInternalServerError();
+    message.message = object.message ?? undefined;
     return message;
   }
 }
 
-function createBaseUser(): User {
-  return { address: "" };
+function createBaseInvalidRequest(): InvalidRequest {
+  return { message: undefined };
 }
 
-export namespace User {
-  export function encode(message: User, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.address !== "") {
-      writer.uint32(10).string(message.address);
+export namespace InvalidRequest {
+  export function encode(message: InvalidRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.message !== undefined) {
+      writer.uint32(10).string(message.message);
     }
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): User {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): InvalidRequest {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseUser();
+    const message = createBaseInvalidRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -364,7 +499,7 @@ export namespace User {
             break;
           }
 
-          message.address = reader.string();
+          message.message = reader.string();
           continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
@@ -375,62 +510,52 @@ export namespace User {
     return message;
   }
 
-  export function fromJSON(object: any): User {
-    return { address: isSet(object.address) ? String(object.address) : "" };
+  export function fromJSON(object: any): InvalidRequest {
+    return { message: isSet(object.message) ? String(object.message) : undefined };
   }
 
-  export function toJSON(message: User): unknown {
+  export function toJSON(message: InvalidRequest): unknown {
     const obj: any = {};
-    message.address !== undefined && (obj.address = message.address);
+    message.message !== undefined && (obj.message = message.message);
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<User>, I>>(base?: I): User {
-    return User.fromPartial(base ?? {});
+  export function create<I extends Exact<DeepPartial<InvalidRequest>, I>>(base?: I): InvalidRequest {
+    return InvalidRequest.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<User>, I>>(object: I): User {
-    const message = createBaseUser();
-    message.address = object.address ?? "";
+  export function fromPartial<I extends Exact<DeepPartial<InvalidRequest>, I>>(object: I): InvalidRequest {
+    const message = createBaseInvalidRequest();
+    message.message = object.message ?? undefined;
     return message;
   }
 }
 
-function createBasePagination(): Pagination {
-  return { limit: 0, offset: 0 };
+function createBaseProfileNotFound(): ProfileNotFound {
+  return { message: undefined };
 }
 
-export namespace Pagination {
-  export function encode(message: Pagination, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.limit !== 0) {
-      writer.uint32(8).int32(message.limit);
-    }
-    if (message.offset !== 0) {
-      writer.uint32(16).int32(message.offset);
+export namespace ProfileNotFound {
+  export function encode(message: ProfileNotFound, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.message !== undefined) {
+      writer.uint32(10).string(message.message);
     }
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): Pagination {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): ProfileNotFound {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBasePagination();
+    const message = createBaseProfileNotFound();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          if (tag !== 8) {
-            break;
-          }
-
-          message.limit = reader.int32();
-          continue;
-        case 2:
-          if (tag !== 16) {
+          if (tag !== 10) {
             break;
           }
 
-          message.offset = reader.int32();
+          message.message = reader.string();
           continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
@@ -441,54 +566,43 @@ export namespace Pagination {
     return message;
   }
 
-  export function fromJSON(object: any): Pagination {
-    return {
-      limit: isSet(object.limit) ? Number(object.limit) : 0,
-      offset: isSet(object.offset) ? Number(object.offset) : 0,
-    };
+  export function fromJSON(object: any): ProfileNotFound {
+    return { message: isSet(object.message) ? String(object.message) : undefined };
   }
 
-  export function toJSON(message: Pagination): unknown {
+  export function toJSON(message: ProfileNotFound): unknown {
     const obj: any = {};
-    message.limit !== undefined && (obj.limit = Math.round(message.limit));
-    message.offset !== undefined && (obj.offset = Math.round(message.offset));
+    message.message !== undefined && (obj.message = message.message);
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<Pagination>, I>>(base?: I): Pagination {
-    return Pagination.fromPartial(base ?? {});
+  export function create<I extends Exact<DeepPartial<ProfileNotFound>, I>>(base?: I): ProfileNotFound {
+    return ProfileNotFound.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<Pagination>, I>>(object: I): Pagination {
-    const message = createBasePagination();
-    message.limit = object.limit ?? 0;
-    message.offset = object.offset ?? 0;
+  export function fromPartial<I extends Exact<DeepPartial<ProfileNotFound>, I>>(object: I): ProfileNotFound {
+    const message = createBaseProfileNotFound();
+    message.message = object.message ?? undefined;
     return message;
   }
 }
 
-function createBaseFriendshipRequestResponse(): FriendshipRequestResponse {
-  return { user: undefined, createdAt: 0, message: undefined };
+function createBaseUser(): User {
+  return { address: "" };
 }
 
-export namespace FriendshipRequestResponse {
-  export function encode(message: FriendshipRequestResponse, 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);
+export namespace User {
+  export function encode(message: User, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
     }
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): FriendshipRequestResponse {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): User {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseFriendshipRequestResponse();
+    const message = createBaseUser();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -497,21 +611,7 @@ export namespace FriendshipRequestResponse {
             break;
           }
 
-          message.user = User.decode(reader, reader.uint32());
-          continue;
-        case 2:
-          if (tag !== 16) {
-            break;
-          }
-
-          message.createdAt = longToNumber(reader.int64() as Long);
-          continue;
-        case 3:
-          if (tag !== 26) {
-            break;
-          }
-
-          message.message = reader.string();
+          message.address = reader.string();
           continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
@@ -522,55 +622,52 @@ export namespace FriendshipRequestResponse {
     return message;
   }
 
-  export function fromJSON(object: any): FriendshipRequestResponse {
-    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,
-    };
+  export function fromJSON(object: any): User {
+    return { address: isSet(object.address) ? String(object.address) : "" };
   }
 
-  export function toJSON(message: FriendshipRequestResponse): unknown {
+  export function toJSON(message: User): 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);
+    message.address !== undefined && (obj.address = message.address);
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<FriendshipRequestResponse>, I>>(
-    base?: I,
-  ): FriendshipRequestResponse {
-    return FriendshipRequestResponse.fromPartial(base ?? {});
+  export function create<I extends Exact<DeepPartial<User>, I>>(base?: I): User {
+    return User.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<FriendshipRequestResponse>, I>>(
-    object: I,
-  ): FriendshipRequestResponse {
-    const message = createBaseFriendshipRequestResponse();
-    message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
-    message.createdAt = object.createdAt ?? 0;
-    message.message = object.message ?? undefined;
+  export function fromPartial<I extends Exact<DeepPartial<User>, I>>(object: I): User {
+    const message = createBaseUser();
+    message.address = object.address ?? "";
     return message;
   }
 }
 
-function createBaseFriendshipRequests(): FriendshipRequests {
-  return { requests: [] };
+function createBaseFriendProfile(): FriendProfile {
+  return { address: "", name: "", hasClaimedName: false, profilePictureUrl: "" };
 }
 
-export namespace FriendshipRequests {
-  export function encode(message: FriendshipRequests, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    for (const v of message.requests) {
-      FriendshipRequestResponse.encode(v!, writer.uint32(10).fork()).ldelim();
+export namespace FriendProfile {
+  export function encode(message: FriendProfile, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+    if (message.name !== "") {
+      writer.uint32(18).string(message.name);
+    }
+    if (message.hasClaimedName === true) {
+      writer.uint32(24).bool(message.hasClaimedName);
+    }
+    if (message.profilePictureUrl !== "") {
+      writer.uint32(34).string(message.profilePictureUrl);
     }
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): FriendshipRequests {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): FriendProfile {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseFriendshipRequests();
+    const message = createBaseFriendProfile();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -579,7 +676,28 @@ export namespace FriendshipRequests {
             break;
           }
 
-          message.requests.push(FriendshipRequestResponse.decode(reader, reader.uint32()));
+          message.address = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+
+          message.hasClaimedName = reader.bool();
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.profilePictureUrl = reader.string();
           continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
@@ -590,54 +708,1542 @@ export namespace FriendshipRequests {
     return message;
   }
 
-  export function fromJSON(object: any): FriendshipRequests {
+  export function fromJSON(object: any): FriendProfile {
     return {
-      requests: Array.isArray(object?.requests)
-        ? object.requests.map((e: any) => FriendshipRequestResponse.fromJSON(e))
-        : [],
+      address: isSet(object.address) ? String(object.address) : "",
+      name: isSet(object.name) ? String(object.name) : "",
+      hasClaimedName: isSet(object.hasClaimedName) ? Boolean(object.hasClaimedName) : false,
+      profilePictureUrl: isSet(object.profilePictureUrl) ? String(object.profilePictureUrl) : "",
     };
   }
 
-  export function toJSON(message: FriendshipRequests): unknown {
+  export function toJSON(message: FriendProfile): unknown {
     const obj: any = {};
-    if (message.requests) {
-      obj.requests = message.requests.map((e) => e ? FriendshipRequestResponse.toJSON(e) : undefined);
-    } else {
-      obj.requests = [];
-    }
+    message.address !== undefined && (obj.address = message.address);
+    message.name !== undefined && (obj.name = message.name);
+    message.hasClaimedName !== undefined && (obj.hasClaimedName = message.hasClaimedName);
+    message.profilePictureUrl !== undefined && (obj.profilePictureUrl = message.profilePictureUrl);
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<FriendshipRequests>, I>>(base?: I): FriendshipRequests {
-    return FriendshipRequests.fromPartial(base ?? {});
+  export function create<I extends Exact<DeepPartial<FriendProfile>, I>>(base?: I): FriendProfile {
+    return FriendProfile.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<FriendshipRequests>, I>>(object: I): FriendshipRequests {
-    const message = createBaseFriendshipRequests();
+  export function fromPartial<I extends Exact<DeepPartial<FriendProfile>, I>>(object: I): FriendProfile {
+    const message = createBaseFriendProfile();
+    message.address = object.address ?? "";
+    message.name = object.name ?? "";
+    message.hasClaimedName = object.hasClaimedName ?? false;
+    message.profilePictureUrl = object.profilePictureUrl ?? "";
+    return message;
+  }
+}
+
+function createBaseBlockedUserProfile(): BlockedUserProfile {
+  return { address: "", name: "", hasClaimedName: false, profilePictureUrl: "", blockedAt: undefined };
+}
+
+export namespace BlockedUserProfile {
+  export function encode(message: BlockedUserProfile, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+    if (message.name !== "") {
+      writer.uint32(18).string(message.name);
+    }
+    if (message.hasClaimedName === true) {
+      writer.uint32(24).bool(message.hasClaimedName);
+    }
+    if (message.profilePictureUrl !== "") {
+      writer.uint32(34).string(message.profilePictureUrl);
+    }
+    if (message.blockedAt !== undefined) {
+      writer.uint32(40).int64(message.blockedAt);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): BlockedUserProfile {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseBlockedUserProfile();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.address = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+
+          message.hasClaimedName = reader.bool();
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.profilePictureUrl = reader.string();
+          continue;
+        case 5:
+          if (tag !== 40) {
+            break;
+          }
+
+          message.blockedAt = longToNumber(reader.int64() as Long);
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): BlockedUserProfile {
+    return {
+      address: isSet(object.address) ? String(object.address) : "",
+      name: isSet(object.name) ? String(object.name) : "",
+      hasClaimedName: isSet(object.hasClaimedName) ? Boolean(object.hasClaimedName) : false,
+      profilePictureUrl: isSet(object.profilePictureUrl) ? String(object.profilePictureUrl) : "",
+      blockedAt: isSet(object.blockedAt) ? Number(object.blockedAt) : undefined,
+    };
+  }
+
+  export function toJSON(message: BlockedUserProfile): unknown {
+    const obj: any = {};
+    message.address !== undefined && (obj.address = message.address);
+    message.name !== undefined && (obj.name = message.name);
+    message.hasClaimedName !== undefined && (obj.hasClaimedName = message.hasClaimedName);
+    message.profilePictureUrl !== undefined && (obj.profilePictureUrl = message.profilePictureUrl);
+    message.blockedAt !== undefined && (obj.blockedAt = Math.round(message.blockedAt));
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<BlockedUserProfile>, I>>(base?: I): BlockedUserProfile {
+    return BlockedUserProfile.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<BlockedUserProfile>, I>>(object: I): BlockedUserProfile {
+    const message = createBaseBlockedUserProfile();
+    message.address = object.address ?? "";
+    message.name = object.name ?? "";
+    message.hasClaimedName = object.hasClaimedName ?? false;
+    message.profilePictureUrl = object.profilePictureUrl ?? "";
+    message.blockedAt = object.blockedAt ?? undefined;
+    return message;
+  }
+}
+
+function createBasePagination(): Pagination {
+  return { limit: 0, offset: 0 };
+}
+
+export namespace Pagination {
+  export function encode(message: Pagination, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.limit !== 0) {
+      writer.uint32(8).int32(message.limit);
+    }
+    if (message.offset !== 0) {
+      writer.uint32(16).int32(message.offset);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): Pagination {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePagination();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.limit = reader.int32();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.offset = reader.int32();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): Pagination {
+    return {
+      limit: isSet(object.limit) ? Number(object.limit) : 0,
+      offset: isSet(object.offset) ? Number(object.offset) : 0,
+    };
+  }
+
+  export function toJSON(message: Pagination): unknown {
+    const obj: any = {};
+    message.limit !== undefined && (obj.limit = Math.round(message.limit));
+    message.offset !== undefined && (obj.offset = Math.round(message.offset));
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<Pagination>, I>>(base?: I): Pagination {
+    return Pagination.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<Pagination>, I>>(object: I): Pagination {
+    const message = createBasePagination();
+    message.limit = object.limit ?? 0;
+    message.offset = object.offset ?? 0;
+    return message;
+  }
+}
+
+function createBaseFriendshipRequestResponse(): FriendshipRequestResponse {
+  return { friend: undefined, createdAt: 0, message: undefined, id: "" };
+}
+
+export namespace FriendshipRequestResponse {
+  export function encode(message: FriendshipRequestResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.friend !== undefined) {
+      FriendProfile.encode(message.friend, 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);
+    }
+    if (message.id !== "") {
+      writer.uint32(34).string(message.id);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): FriendshipRequestResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFriendshipRequestResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.friend = FriendProfile.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.createdAt = longToNumber(reader.int64() as Long);
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.message = reader.string();
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.id = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): FriendshipRequestResponse {
+    return {
+      friend: isSet(object.friend) ? FriendProfile.fromJSON(object.friend) : undefined,
+      createdAt: isSet(object.createdAt) ? Number(object.createdAt) : 0,
+      message: isSet(object.message) ? String(object.message) : undefined,
+      id: isSet(object.id) ? String(object.id) : "",
+    };
+  }
+
+  export function toJSON(message: FriendshipRequestResponse): unknown {
+    const obj: any = {};
+    message.friend !== undefined && (obj.friend = message.friend ? FriendProfile.toJSON(message.friend) : undefined);
+    message.createdAt !== undefined && (obj.createdAt = Math.round(message.createdAt));
+    message.message !== undefined && (obj.message = message.message);
+    message.id !== undefined && (obj.id = message.id);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<FriendshipRequestResponse>, I>>(
+    base?: I,
+  ): FriendshipRequestResponse {
+    return FriendshipRequestResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<FriendshipRequestResponse>, I>>(
+    object: I,
+  ): FriendshipRequestResponse {
+    const message = createBaseFriendshipRequestResponse();
+    message.friend = (object.friend !== undefined && object.friend !== null)
+      ? FriendProfile.fromPartial(object.friend)
+      : undefined;
+    message.createdAt = object.createdAt ?? 0;
+    message.message = object.message ?? undefined;
+    message.id = object.id ?? "";
+    return message;
+  }
+}
+
+function createBaseFriendshipRequests(): FriendshipRequests {
+  return { requests: [] };
+}
+
+export namespace FriendshipRequests {
+  export function encode(message: FriendshipRequests, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.requests) {
+      FriendshipRequestResponse.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): FriendshipRequests {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFriendshipRequests();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.requests.push(FriendshipRequestResponse.decode(reader, reader.uint32()));
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): FriendshipRequests {
+    return {
+      requests: Array.isArray(object?.requests)
+        ? object.requests.map((e: any) => FriendshipRequestResponse.fromJSON(e))
+        : [],
+    };
+  }
+
+  export function toJSON(message: FriendshipRequests): unknown {
+    const obj: any = {};
+    if (message.requests) {
+      obj.requests = message.requests.map((e) => e ? FriendshipRequestResponse.toJSON(e) : undefined);
+    } else {
+      obj.requests = [];
+    }
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<FriendshipRequests>, I>>(base?: I): FriendshipRequests {
+    return FriendshipRequests.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<FriendshipRequests>, I>>(object: I): FriendshipRequests {
+    const message = createBaseFriendshipRequests();
     message.requests = object.requests?.map((e) => FriendshipRequestResponse.fromPartial(e)) || [];
     return message;
   }
 }
 
-function createBaseGetFriendsPayload(): GetFriendsPayload {
-  return { pagination: undefined, status: undefined };
+function createBaseGetFriendsPayload(): GetFriendsPayload {
+  return { pagination: undefined };
+}
+
+export namespace GetFriendsPayload {
+  export function encode(message: GetFriendsPayload, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.pagination !== undefined) {
+      Pagination.encode(message.pagination, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): GetFriendsPayload {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetFriendsPayload();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.pagination = Pagination.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): GetFriendsPayload {
+    return { pagination: isSet(object.pagination) ? Pagination.fromJSON(object.pagination) : undefined };
+  }
+
+  export function toJSON(message: GetFriendsPayload): unknown {
+    const obj: any = {};
+    message.pagination !== undefined &&
+      (obj.pagination = message.pagination ? Pagination.toJSON(message.pagination) : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<GetFriendsPayload>, I>>(base?: I): GetFriendsPayload {
+    return GetFriendsPayload.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<GetFriendsPayload>, I>>(object: I): GetFriendsPayload {
+    const message = createBaseGetFriendsPayload();
+    message.pagination = (object.pagination !== undefined && object.pagination !== null)
+      ? Pagination.fromPartial(object.pagination)
+      : undefined;
+    return message;
+  }
+}
+
+function createBaseGetFriendshipRequestsPayload(): GetFriendshipRequestsPayload {
+  return { pagination: undefined };
+}
+
+export namespace GetFriendshipRequestsPayload {
+  export function encode(message: GetFriendshipRequestsPayload, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.pagination !== undefined) {
+      Pagination.encode(message.pagination, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): GetFriendshipRequestsPayload {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetFriendshipRequestsPayload();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.pagination = Pagination.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): GetFriendshipRequestsPayload {
+    return { pagination: isSet(object.pagination) ? Pagination.fromJSON(object.pagination) : undefined };
+  }
+
+  export function toJSON(message: GetFriendshipRequestsPayload): unknown {
+    const obj: any = {};
+    message.pagination !== undefined &&
+      (obj.pagination = message.pagination ? Pagination.toJSON(message.pagination) : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<GetFriendshipRequestsPayload>, I>>(
+    base?: I,
+  ): GetFriendshipRequestsPayload {
+    return GetFriendshipRequestsPayload.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<GetFriendshipRequestsPayload>, I>>(
+    object: I,
+  ): GetFriendshipRequestsPayload {
+    const message = createBaseGetFriendshipRequestsPayload();
+    message.pagination = (object.pagination !== undefined && object.pagination !== null)
+      ? Pagination.fromPartial(object.pagination)
+      : undefined;
+    return message;
+  }
+}
+
+function createBaseUpsertFriendshipPayload(): UpsertFriendshipPayload {
+  return { action: undefined };
+}
+
+export namespace UpsertFriendshipPayload {
+  export function encode(message: UpsertFriendshipPayload, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    switch (message.action?.$case) {
+      case "request":
+        UpsertFriendshipPayload_RequestPayload.encode(message.action.request, writer.uint32(10).fork()).ldelim();
+        break;
+      case "accept":
+        UpsertFriendshipPayload_AcceptPayload.encode(message.action.accept, writer.uint32(18).fork()).ldelim();
+        break;
+      case "reject":
+        UpsertFriendshipPayload_RejectPayload.encode(message.action.reject, writer.uint32(34).fork()).ldelim();
+        break;
+      case "delete":
+        UpsertFriendshipPayload_DeletePayload.encode(message.action.delete, writer.uint32(42).fork()).ldelim();
+        break;
+      case "cancel":
+        UpsertFriendshipPayload_CancelPayload.encode(message.action.cancel, writer.uint32(50).fork()).ldelim();
+        break;
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): UpsertFriendshipPayload {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUpsertFriendshipPayload();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.action = {
+            $case: "request",
+            request: UpsertFriendshipPayload_RequestPayload.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.action = {
+            $case: "accept",
+            accept: UpsertFriendshipPayload_AcceptPayload.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.action = {
+            $case: "reject",
+            reject: UpsertFriendshipPayload_RejectPayload.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.action = {
+            $case: "delete",
+            delete: UpsertFriendshipPayload_DeletePayload.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 6:
+          if (tag !== 50) {
+            break;
+          }
+
+          message.action = {
+            $case: "cancel",
+            cancel: UpsertFriendshipPayload_CancelPayload.decode(reader, reader.uint32()),
+          };
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): UpsertFriendshipPayload {
+    return {
+      action: isSet(object.request)
+        ? { $case: "request", request: UpsertFriendshipPayload_RequestPayload.fromJSON(object.request) }
+        : isSet(object.accept)
+        ? { $case: "accept", accept: UpsertFriendshipPayload_AcceptPayload.fromJSON(object.accept) }
+        : isSet(object.reject)
+        ? { $case: "reject", reject: UpsertFriendshipPayload_RejectPayload.fromJSON(object.reject) }
+        : isSet(object.delete)
+        ? { $case: "delete", delete: UpsertFriendshipPayload_DeletePayload.fromJSON(object.delete) }
+        : isSet(object.cancel)
+        ? { $case: "cancel", cancel: UpsertFriendshipPayload_CancelPayload.fromJSON(object.cancel) }
+        : undefined,
+    };
+  }
+
+  export function toJSON(message: UpsertFriendshipPayload): unknown {
+    const obj: any = {};
+    message.action?.$case === "request" &&
+      (obj.request = message.action?.request
+        ? UpsertFriendshipPayload_RequestPayload.toJSON(message.action?.request)
+        : undefined);
+    message.action?.$case === "accept" &&
+      (obj.accept = message.action?.accept
+        ? UpsertFriendshipPayload_AcceptPayload.toJSON(message.action?.accept)
+        : undefined);
+    message.action?.$case === "reject" &&
+      (obj.reject = message.action?.reject
+        ? UpsertFriendshipPayload_RejectPayload.toJSON(message.action?.reject)
+        : undefined);
+    message.action?.$case === "delete" &&
+      (obj.delete = message.action?.delete
+        ? UpsertFriendshipPayload_DeletePayload.toJSON(message.action?.delete)
+        : undefined);
+    message.action?.$case === "cancel" &&
+      (obj.cancel = message.action?.cancel
+        ? UpsertFriendshipPayload_CancelPayload.toJSON(message.action?.cancel)
+        : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<UpsertFriendshipPayload>, I>>(base?: I): UpsertFriendshipPayload {
+    return UpsertFriendshipPayload.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<UpsertFriendshipPayload>, I>>(
+    object: I,
+  ): UpsertFriendshipPayload {
+    const message = createBaseUpsertFriendshipPayload();
+    if (object.action?.$case === "request" && object.action?.request !== undefined && object.action?.request !== null) {
+      message.action = {
+        $case: "request",
+        request: UpsertFriendshipPayload_RequestPayload.fromPartial(object.action.request),
+      };
+    }
+    if (object.action?.$case === "accept" && object.action?.accept !== undefined && object.action?.accept !== null) {
+      message.action = {
+        $case: "accept",
+        accept: UpsertFriendshipPayload_AcceptPayload.fromPartial(object.action.accept),
+      };
+    }
+    if (object.action?.$case === "reject" && object.action?.reject !== undefined && object.action?.reject !== null) {
+      message.action = {
+        $case: "reject",
+        reject: UpsertFriendshipPayload_RejectPayload.fromPartial(object.action.reject),
+      };
+    }
+    if (object.action?.$case === "delete" && object.action?.delete !== undefined && object.action?.delete !== null) {
+      message.action = {
+        $case: "delete",
+        delete: UpsertFriendshipPayload_DeletePayload.fromPartial(object.action.delete),
+      };
+    }
+    if (object.action?.$case === "cancel" && object.action?.cancel !== undefined && object.action?.cancel !== null) {
+      message.action = {
+        $case: "cancel",
+        cancel: UpsertFriendshipPayload_CancelPayload.fromPartial(object.action.cancel),
+      };
+    }
+    return message;
+  }
+}
+
+function createBaseUpsertFriendshipPayload_RequestPayload(): UpsertFriendshipPayload_RequestPayload {
+  return { user: undefined, message: undefined };
+}
+
+export namespace UpsertFriendshipPayload_RequestPayload {
+  export function encode(
+    message: UpsertFriendshipPayload_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;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): UpsertFriendshipPayload_RequestPayload {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUpsertFriendshipPayload_RequestPayload();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.user = User.decode(reader, reader.uint32());
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.message = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): UpsertFriendshipPayload_RequestPayload {
+    return {
+      user: isSet(object.user) ? User.fromJSON(object.user) : undefined,
+      message: isSet(object.message) ? String(object.message) : undefined,
+    };
+  }
+
+  export function toJSON(message: UpsertFriendshipPayload_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;
+  }
+
+  export function create<I extends Exact<DeepPartial<UpsertFriendshipPayload_RequestPayload>, I>>(
+    base?: I,
+  ): UpsertFriendshipPayload_RequestPayload {
+    return UpsertFriendshipPayload_RequestPayload.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<UpsertFriendshipPayload_RequestPayload>, I>>(
+    object: I,
+  ): UpsertFriendshipPayload_RequestPayload {
+    const message = createBaseUpsertFriendshipPayload_RequestPayload();
+    message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
+    message.message = object.message ?? undefined;
+    return message;
+  }
+}
+
+function createBaseUpsertFriendshipPayload_AcceptPayload(): UpsertFriendshipPayload_AcceptPayload {
+  return { user: undefined };
+}
+
+export namespace UpsertFriendshipPayload_AcceptPayload {
+  export function encode(
+    message: UpsertFriendshipPayload_AcceptPayload,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    if (message.user !== undefined) {
+      User.encode(message.user, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): UpsertFriendshipPayload_AcceptPayload {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUpsertFriendshipPayload_AcceptPayload();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.user = User.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): UpsertFriendshipPayload_AcceptPayload {
+    return { user: isSet(object.user) ? User.fromJSON(object.user) : undefined };
+  }
+
+  export function toJSON(message: UpsertFriendshipPayload_AcceptPayload): unknown {
+    const obj: any = {};
+    message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<UpsertFriendshipPayload_AcceptPayload>, I>>(
+    base?: I,
+  ): UpsertFriendshipPayload_AcceptPayload {
+    return UpsertFriendshipPayload_AcceptPayload.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<UpsertFriendshipPayload_AcceptPayload>, I>>(
+    object: I,
+  ): UpsertFriendshipPayload_AcceptPayload {
+    const message = createBaseUpsertFriendshipPayload_AcceptPayload();
+    message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
+    return message;
+  }
+}
+
+function createBaseUpsertFriendshipPayload_RejectPayload(): UpsertFriendshipPayload_RejectPayload {
+  return { user: undefined };
+}
+
+export namespace UpsertFriendshipPayload_RejectPayload {
+  export function encode(
+    message: UpsertFriendshipPayload_RejectPayload,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    if (message.user !== undefined) {
+      User.encode(message.user, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): UpsertFriendshipPayload_RejectPayload {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUpsertFriendshipPayload_RejectPayload();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.user = User.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): UpsertFriendshipPayload_RejectPayload {
+    return { user: isSet(object.user) ? User.fromJSON(object.user) : undefined };
+  }
+
+  export function toJSON(message: UpsertFriendshipPayload_RejectPayload): unknown {
+    const obj: any = {};
+    message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<UpsertFriendshipPayload_RejectPayload>, I>>(
+    base?: I,
+  ): UpsertFriendshipPayload_RejectPayload {
+    return UpsertFriendshipPayload_RejectPayload.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<UpsertFriendshipPayload_RejectPayload>, I>>(
+    object: I,
+  ): UpsertFriendshipPayload_RejectPayload {
+    const message = createBaseUpsertFriendshipPayload_RejectPayload();
+    message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
+    return message;
+  }
+}
+
+function createBaseUpsertFriendshipPayload_DeletePayload(): UpsertFriendshipPayload_DeletePayload {
+  return { user: undefined };
+}
+
+export namespace UpsertFriendshipPayload_DeletePayload {
+  export function encode(
+    message: UpsertFriendshipPayload_DeletePayload,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    if (message.user !== undefined) {
+      User.encode(message.user, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): UpsertFriendshipPayload_DeletePayload {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUpsertFriendshipPayload_DeletePayload();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.user = User.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): UpsertFriendshipPayload_DeletePayload {
+    return { user: isSet(object.user) ? User.fromJSON(object.user) : undefined };
+  }
+
+  export function toJSON(message: UpsertFriendshipPayload_DeletePayload): unknown {
+    const obj: any = {};
+    message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<UpsertFriendshipPayload_DeletePayload>, I>>(
+    base?: I,
+  ): UpsertFriendshipPayload_DeletePayload {
+    return UpsertFriendshipPayload_DeletePayload.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<UpsertFriendshipPayload_DeletePayload>, I>>(
+    object: I,
+  ): UpsertFriendshipPayload_DeletePayload {
+    const message = createBaseUpsertFriendshipPayload_DeletePayload();
+    message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
+    return message;
+  }
+}
+
+function createBaseUpsertFriendshipPayload_CancelPayload(): UpsertFriendshipPayload_CancelPayload {
+  return { user: undefined };
+}
+
+export namespace UpsertFriendshipPayload_CancelPayload {
+  export function encode(
+    message: UpsertFriendshipPayload_CancelPayload,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    if (message.user !== undefined) {
+      User.encode(message.user, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): UpsertFriendshipPayload_CancelPayload {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUpsertFriendshipPayload_CancelPayload();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.user = User.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): UpsertFriendshipPayload_CancelPayload {
+    return { user: isSet(object.user) ? User.fromJSON(object.user) : undefined };
+  }
+
+  export function toJSON(message: UpsertFriendshipPayload_CancelPayload): unknown {
+    const obj: any = {};
+    message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<UpsertFriendshipPayload_CancelPayload>, I>>(
+    base?: I,
+  ): UpsertFriendshipPayload_CancelPayload {
+    return UpsertFriendshipPayload_CancelPayload.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<UpsertFriendshipPayload_CancelPayload>, I>>(
+    object: I,
+  ): UpsertFriendshipPayload_CancelPayload {
+    const message = createBaseUpsertFriendshipPayload_CancelPayload();
+    message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
+    return message;
+  }
+}
+
+function createBaseGetMutualFriendsPayload(): GetMutualFriendsPayload {
+  return { user: undefined, pagination: undefined };
+}
+
+export namespace GetMutualFriendsPayload {
+  export function encode(message: GetMutualFriendsPayload, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.user !== undefined) {
+      User.encode(message.user, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.pagination !== undefined) {
+      Pagination.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): GetMutualFriendsPayload {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetMutualFriendsPayload();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.user = User.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.pagination = Pagination.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): GetMutualFriendsPayload {
+    return {
+      user: isSet(object.user) ? User.fromJSON(object.user) : undefined,
+      pagination: isSet(object.pagination) ? Pagination.fromJSON(object.pagination) : undefined,
+    };
+  }
+
+  export function toJSON(message: GetMutualFriendsPayload): unknown {
+    const obj: any = {};
+    message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
+    message.pagination !== undefined &&
+      (obj.pagination = message.pagination ? Pagination.toJSON(message.pagination) : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<GetMutualFriendsPayload>, I>>(base?: I): GetMutualFriendsPayload {
+    return GetMutualFriendsPayload.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<GetMutualFriendsPayload>, I>>(
+    object: I,
+  ): GetMutualFriendsPayload {
+    const message = createBaseGetMutualFriendsPayload();
+    message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
+    message.pagination = (object.pagination !== undefined && object.pagination !== null)
+      ? Pagination.fromPartial(object.pagination)
+      : undefined;
+    return message;
+  }
+}
+
+function createBasePaginatedResponse(): PaginatedResponse {
+  return { total: 0, page: 0 };
+}
+
+export namespace PaginatedResponse {
+  export function encode(message: PaginatedResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.total !== 0) {
+      writer.uint32(8).int32(message.total);
+    }
+    if (message.page !== 0) {
+      writer.uint32(16).int32(message.page);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): PaginatedResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePaginatedResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.total = reader.int32();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.page = reader.int32();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): PaginatedResponse {
+    return {
+      total: isSet(object.total) ? Number(object.total) : 0,
+      page: isSet(object.page) ? Number(object.page) : 0,
+    };
+  }
+
+  export function toJSON(message: PaginatedResponse): unknown {
+    const obj: any = {};
+    message.total !== undefined && (obj.total = Math.round(message.total));
+    message.page !== undefined && (obj.page = Math.round(message.page));
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<PaginatedResponse>, I>>(base?: I): PaginatedResponse {
+    return PaginatedResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<PaginatedResponse>, I>>(object: I): PaginatedResponse {
+    const message = createBasePaginatedResponse();
+    message.total = object.total ?? 0;
+    message.page = object.page ?? 0;
+    return message;
+  }
+}
+
+function createBasePaginatedFriendsProfilesResponse(): PaginatedFriendsProfilesResponse {
+  return { friends: [], paginationData: undefined };
+}
+
+export namespace PaginatedFriendsProfilesResponse {
+  export function encode(
+    message: PaginatedFriendsProfilesResponse,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    for (const v of message.friends) {
+      FriendProfile.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.paginationData !== undefined) {
+      PaginatedResponse.encode(message.paginationData, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): PaginatedFriendsProfilesResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePaginatedFriendsProfilesResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.friends.push(FriendProfile.decode(reader, reader.uint32()));
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.paginationData = PaginatedResponse.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): PaginatedFriendsProfilesResponse {
+    return {
+      friends: Array.isArray(object?.friends) ? object.friends.map((e: any) => FriendProfile.fromJSON(e)) : [],
+      paginationData: isSet(object.paginationData) ? PaginatedResponse.fromJSON(object.paginationData) : undefined,
+    };
+  }
+
+  export function toJSON(message: PaginatedFriendsProfilesResponse): unknown {
+    const obj: any = {};
+    if (message.friends) {
+      obj.friends = message.friends.map((e) => e ? FriendProfile.toJSON(e) : undefined);
+    } else {
+      obj.friends = [];
+    }
+    message.paginationData !== undefined &&
+      (obj.paginationData = message.paginationData ? PaginatedResponse.toJSON(message.paginationData) : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<PaginatedFriendsProfilesResponse>, I>>(
+    base?: I,
+  ): PaginatedFriendsProfilesResponse {
+    return PaginatedFriendsProfilesResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<PaginatedFriendsProfilesResponse>, I>>(
+    object: I,
+  ): PaginatedFriendsProfilesResponse {
+    const message = createBasePaginatedFriendsProfilesResponse();
+    message.friends = object.friends?.map((e) => FriendProfile.fromPartial(e)) || [];
+    message.paginationData = (object.paginationData !== undefined && object.paginationData !== null)
+      ? PaginatedResponse.fromPartial(object.paginationData)
+      : undefined;
+    return message;
+  }
+}
+
+function createBasePaginatedFriendshipRequestsResponse(): PaginatedFriendshipRequestsResponse {
+  return { response: undefined, paginationData: undefined };
+}
+
+export namespace PaginatedFriendshipRequestsResponse {
+  export function encode(
+    message: PaginatedFriendshipRequestsResponse,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    switch (message.response?.$case) {
+      case "requests":
+        FriendshipRequests.encode(message.response.requests, writer.uint32(10).fork()).ldelim();
+        break;
+      case "internalServerError":
+        InternalServerError.encode(message.response.internalServerError, writer.uint32(18).fork()).ldelim();
+        break;
+    }
+    if (message.paginationData !== undefined) {
+      PaginatedResponse.encode(message.paginationData, writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): PaginatedFriendshipRequestsResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePaginatedFriendshipRequestsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.response = { $case: "requests", requests: FriendshipRequests.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.paginationData = PaginatedResponse.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): PaginatedFriendshipRequestsResponse {
+    return {
+      response: isSet(object.requests)
+        ? { $case: "requests", requests: FriendshipRequests.fromJSON(object.requests) }
+        : isSet(object.internalServerError)
+        ? {
+          $case: "internalServerError",
+          internalServerError: InternalServerError.fromJSON(object.internalServerError),
+        }
+        : undefined,
+      paginationData: isSet(object.paginationData) ? PaginatedResponse.fromJSON(object.paginationData) : undefined,
+    };
+  }
+
+  export function toJSON(message: PaginatedFriendshipRequestsResponse): unknown {
+    const obj: any = {};
+    message.response?.$case === "requests" &&
+      (obj.requests = message.response?.requests ? FriendshipRequests.toJSON(message.response?.requests) : undefined);
+    message.response?.$case === "internalServerError" &&
+      (obj.internalServerError = message.response?.internalServerError
+        ? InternalServerError.toJSON(message.response?.internalServerError)
+        : undefined);
+    message.paginationData !== undefined &&
+      (obj.paginationData = message.paginationData ? PaginatedResponse.toJSON(message.paginationData) : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<PaginatedFriendshipRequestsResponse>, I>>(
+    base?: I,
+  ): PaginatedFriendshipRequestsResponse {
+    return PaginatedFriendshipRequestsResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<PaginatedFriendshipRequestsResponse>, I>>(
+    object: I,
+  ): PaginatedFriendshipRequestsResponse {
+    const message = createBasePaginatedFriendshipRequestsResponse();
+    if (
+      object.response?.$case === "requests" &&
+      object.response?.requests !== undefined &&
+      object.response?.requests !== null
+    ) {
+      message.response = { $case: "requests", requests: FriendshipRequests.fromPartial(object.response.requests) };
+    }
+    if (
+      object.response?.$case === "internalServerError" &&
+      object.response?.internalServerError !== undefined &&
+      object.response?.internalServerError !== null
+    ) {
+      message.response = {
+        $case: "internalServerError",
+        internalServerError: InternalServerError.fromPartial(object.response.internalServerError),
+      };
+    }
+    message.paginationData = (object.paginationData !== undefined && object.paginationData !== null)
+      ? PaginatedResponse.fromPartial(object.paginationData)
+      : undefined;
+    return message;
+  }
+}
+
+function createBaseUpsertFriendshipResponse(): UpsertFriendshipResponse {
+  return { response: undefined };
+}
+
+export namespace UpsertFriendshipResponse {
+  export function encode(message: UpsertFriendshipResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    switch (message.response?.$case) {
+      case "accepted":
+        UpsertFriendshipResponse_Accepted.encode(message.response.accepted, writer.uint32(10).fork()).ldelim();
+        break;
+      case "invalidFriendshipAction":
+        InvalidFriendshipAction.encode(message.response.invalidFriendshipAction, writer.uint32(18).fork()).ldelim();
+        break;
+      case "internalServerError":
+        InternalServerError.encode(message.response.internalServerError, writer.uint32(26).fork()).ldelim();
+        break;
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): UpsertFriendshipResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUpsertFriendshipResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.response = {
+            $case: "accepted",
+            accepted: UpsertFriendshipResponse_Accepted.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.response = {
+            $case: "invalidFriendshipAction",
+            invalidFriendshipAction: InvalidFriendshipAction.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.response = {
+            $case: "internalServerError",
+            internalServerError: InternalServerError.decode(reader, reader.uint32()),
+          };
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): UpsertFriendshipResponse {
+    return {
+      response: isSet(object.accepted)
+        ? { $case: "accepted", accepted: UpsertFriendshipResponse_Accepted.fromJSON(object.accepted) }
+        : isSet(object.invalidFriendshipAction)
+        ? {
+          $case: "invalidFriendshipAction",
+          invalidFriendshipAction: InvalidFriendshipAction.fromJSON(object.invalidFriendshipAction),
+        }
+        : isSet(object.internalServerError)
+        ? {
+          $case: "internalServerError",
+          internalServerError: InternalServerError.fromJSON(object.internalServerError),
+        }
+        : undefined,
+    };
+  }
+
+  export function toJSON(message: UpsertFriendshipResponse): unknown {
+    const obj: any = {};
+    message.response?.$case === "accepted" &&
+      (obj.accepted = message.response?.accepted
+        ? UpsertFriendshipResponse_Accepted.toJSON(message.response?.accepted)
+        : undefined);
+    message.response?.$case === "invalidFriendshipAction" &&
+      (obj.invalidFriendshipAction = message.response?.invalidFriendshipAction
+        ? InvalidFriendshipAction.toJSON(message.response?.invalidFriendshipAction)
+        : undefined);
+    message.response?.$case === "internalServerError" &&
+      (obj.internalServerError = message.response?.internalServerError
+        ? InternalServerError.toJSON(message.response?.internalServerError)
+        : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<UpsertFriendshipResponse>, I>>(
+    base?: I,
+  ): UpsertFriendshipResponse {
+    return UpsertFriendshipResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<UpsertFriendshipResponse>, I>>(
+    object: I,
+  ): UpsertFriendshipResponse {
+    const message = createBaseUpsertFriendshipResponse();
+    if (
+      object.response?.$case === "accepted" &&
+      object.response?.accepted !== undefined &&
+      object.response?.accepted !== null
+    ) {
+      message.response = {
+        $case: "accepted",
+        accepted: UpsertFriendshipResponse_Accepted.fromPartial(object.response.accepted),
+      };
+    }
+    if (
+      object.response?.$case === "invalidFriendshipAction" &&
+      object.response?.invalidFriendshipAction !== undefined &&
+      object.response?.invalidFriendshipAction !== null
+    ) {
+      message.response = {
+        $case: "invalidFriendshipAction",
+        invalidFriendshipAction: InvalidFriendshipAction.fromPartial(object.response.invalidFriendshipAction),
+      };
+    }
+    if (
+      object.response?.$case === "internalServerError" &&
+      object.response?.internalServerError !== undefined &&
+      object.response?.internalServerError !== null
+    ) {
+      message.response = {
+        $case: "internalServerError",
+        internalServerError: InternalServerError.fromPartial(object.response.internalServerError),
+      };
+    }
+    return message;
+  }
+}
+
+function createBaseUpsertFriendshipResponse_Accepted(): UpsertFriendshipResponse_Accepted {
+  return { id: "", createdAt: 0, friend: undefined, message: undefined };
 }
 
-export namespace GetFriendsPayload {
-  export function encode(message: GetFriendsPayload, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.pagination !== undefined) {
-      Pagination.encode(message.pagination, writer.uint32(10).fork()).ldelim();
+export namespace UpsertFriendshipResponse_Accepted {
+  export function encode(
+    message: UpsertFriendshipResponse_Accepted,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    if (message.id !== "") {
+      writer.uint32(10).string(message.id);
     }
-    if (message.status !== undefined) {
-      writer.uint32(16).int32(message.status);
+    if (message.createdAt !== 0) {
+      writer.uint32(16).int64(message.createdAt);
+    }
+    if (message.friend !== undefined) {
+      FriendProfile.encode(message.friend, writer.uint32(26).fork()).ldelim();
+    }
+    if (message.message !== undefined) {
+      writer.uint32(34).string(message.message);
     }
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): GetFriendsPayload {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): UpsertFriendshipResponse_Accepted {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseGetFriendsPayload();
+    const message = createBaseUpsertFriendshipResponse_Accepted();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -646,79 +2252,28 @@ export namespace GetFriendsPayload {
             break;
           }
 
-          message.pagination = Pagination.decode(reader, reader.uint32());
+          message.id = reader.string();
           continue;
         case 2:
           if (tag !== 16) {
             break;
           }
 
-          message.status = reader.int32() as any;
+          message.createdAt = longToNumber(reader.int64() as Long);
           continue;
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skipType(tag & 7);
-    }
-    return message;
-  }
-
-  export function fromJSON(object: any): GetFriendsPayload {
-    return {
-      pagination: isSet(object.pagination) ? Pagination.fromJSON(object.pagination) : undefined,
-      status: isSet(object.status) ? connectivityStatusFromJSON(object.status) : undefined,
-    };
-  }
-
-  export function toJSON(message: GetFriendsPayload): unknown {
-    const obj: any = {};
-    message.pagination !== undefined &&
-      (obj.pagination = message.pagination ? Pagination.toJSON(message.pagination) : undefined);
-    message.status !== undefined &&
-      (obj.status = message.status !== undefined ? connectivityStatusToJSON(message.status) : undefined);
-    return obj;
-  }
-
-  export function create<I extends Exact<DeepPartial<GetFriendsPayload>, I>>(base?: I): GetFriendsPayload {
-    return GetFriendsPayload.fromPartial(base ?? {});
-  }
-
-  export function fromPartial<I extends Exact<DeepPartial<GetFriendsPayload>, I>>(object: I): GetFriendsPayload {
-    const message = createBaseGetFriendsPayload();
-    message.pagination = (object.pagination !== undefined && object.pagination !== null)
-      ? Pagination.fromPartial(object.pagination)
-      : undefined;
-    message.status = object.status ?? undefined;
-    return message;
-  }
-}
-
-function createBaseGetFriendshipRequestsPayload(): GetFriendshipRequestsPayload {
-  return { pagination: undefined };
-}
-
-export namespace GetFriendshipRequestsPayload {
-  export function encode(message: GetFriendshipRequestsPayload, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.pagination !== undefined) {
-      Pagination.encode(message.pagination, writer.uint32(10).fork()).ldelim();
-    }
-    return writer;
-  }
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): GetFriendshipRequestsPayload {
-    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseGetFriendshipRequestsPayload();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1:
-          if (tag !== 10) {
+          message.friend = FriendProfile.decode(reader, reader.uint32());
+          continue;
+        case 4:
+          if (tag !== 34) {
             break;
           }
 
-          message.pagination = Pagination.decode(reader, reader.uint32());
+          message.message = reader.string();
           continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
@@ -729,64 +2284,77 @@ export namespace GetFriendshipRequestsPayload {
     return message;
   }
 
-  export function fromJSON(object: any): GetFriendshipRequestsPayload {
-    return { pagination: isSet(object.pagination) ? Pagination.fromJSON(object.pagination) : undefined };
+  export function fromJSON(object: any): UpsertFriendshipResponse_Accepted {
+    return {
+      id: isSet(object.id) ? String(object.id) : "",
+      createdAt: isSet(object.createdAt) ? Number(object.createdAt) : 0,
+      friend: isSet(object.friend) ? FriendProfile.fromJSON(object.friend) : undefined,
+      message: isSet(object.message) ? String(object.message) : undefined,
+    };
   }
 
-  export function toJSON(message: GetFriendshipRequestsPayload): unknown {
+  export function toJSON(message: UpsertFriendshipResponse_Accepted): unknown {
     const obj: any = {};
-    message.pagination !== undefined &&
-      (obj.pagination = message.pagination ? Pagination.toJSON(message.pagination) : undefined);
+    message.id !== undefined && (obj.id = message.id);
+    message.createdAt !== undefined && (obj.createdAt = Math.round(message.createdAt));
+    message.friend !== undefined && (obj.friend = message.friend ? FriendProfile.toJSON(message.friend) : undefined);
+    message.message !== undefined && (obj.message = message.message);
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<GetFriendshipRequestsPayload>, I>>(
+  export function create<I extends Exact<DeepPartial<UpsertFriendshipResponse_Accepted>, I>>(
     base?: I,
-  ): GetFriendshipRequestsPayload {
-    return GetFriendshipRequestsPayload.fromPartial(base ?? {});
+  ): UpsertFriendshipResponse_Accepted {
+    return UpsertFriendshipResponse_Accepted.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<GetFriendshipRequestsPayload>, I>>(
+  export function fromPartial<I extends Exact<DeepPartial<UpsertFriendshipResponse_Accepted>, I>>(
     object: I,
-  ): GetFriendshipRequestsPayload {
-    const message = createBaseGetFriendshipRequestsPayload();
-    message.pagination = (object.pagination !== undefined && object.pagination !== null)
-      ? Pagination.fromPartial(object.pagination)
+  ): UpsertFriendshipResponse_Accepted {
+    const message = createBaseUpsertFriendshipResponse_Accepted();
+    message.id = object.id ?? "";
+    message.createdAt = object.createdAt ?? 0;
+    message.friend = (object.friend !== undefined && object.friend !== null)
+      ? FriendProfile.fromPartial(object.friend)
       : undefined;
+    message.message = object.message ?? undefined;
     return message;
   }
 }
 
-function createBaseUpsertFriendshipPayload(): UpsertFriendshipPayload {
-  return { action: undefined };
+function createBaseFriendshipUpdate(): FriendshipUpdate {
+  return { update: undefined };
 }
 
-export namespace UpsertFriendshipPayload {
-  export function encode(message: UpsertFriendshipPayload, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    switch (message.action?.$case) {
+export namespace FriendshipUpdate {
+  export function encode(message: FriendshipUpdate, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    switch (message.update?.$case) {
       case "request":
-        UpsertFriendshipPayload_RequestPayload.encode(message.action.request, writer.uint32(10).fork()).ldelim();
+        FriendshipUpdate_RequestResponse.encode(message.update.request, writer.uint32(10).fork()).ldelim();
         break;
       case "accept":
-        UpsertFriendshipPayload_AcceptPayload.encode(message.action.accept, writer.uint32(18).fork()).ldelim();
+        FriendshipUpdate_AcceptResponse.encode(message.update.accept, writer.uint32(18).fork()).ldelim();
         break;
       case "reject":
-        UpsertFriendshipPayload_RejectPayload.encode(message.action.reject, writer.uint32(34).fork()).ldelim();
+        FriendshipUpdate_RejectResponse.encode(message.update.reject, writer.uint32(26).fork()).ldelim();
         break;
       case "delete":
-        UpsertFriendshipPayload_DeletePayload.encode(message.action.delete, writer.uint32(42).fork()).ldelim();
+        FriendshipUpdate_DeleteResponse.encode(message.update.delete, writer.uint32(34).fork()).ldelim();
         break;
       case "cancel":
-        UpsertFriendshipPayload_CancelPayload.encode(message.action.cancel, writer.uint32(50).fork()).ldelim();
+        FriendshipUpdate_CancelResponse.encode(message.update.cancel, writer.uint32(42).fork()).ldelim();
+        break;
+      case "block":
+        FriendshipUpdate_BlockResponse.encode(message.update.block, writer.uint32(50).fork()).ldelim();
         break;
     }
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): UpsertFriendshipPayload {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): FriendshipUpdate {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseUpsertFriendshipPayload();
+    const message = createBaseFriendshipUpdate();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -795,9 +2363,9 @@ export namespace UpsertFriendshipPayload {
             break;
           }
 
-          message.action = {
+          message.update = {
             $case: "request",
-            request: UpsertFriendshipPayload_RequestPayload.decode(reader, reader.uint32()),
+            request: FriendshipUpdate_RequestResponse.decode(reader, reader.uint32()),
           };
           continue;
         case 2:
@@ -805,40 +2373,35 @@ export namespace UpsertFriendshipPayload {
             break;
           }
 
-          message.action = {
-            $case: "accept",
-            accept: UpsertFriendshipPayload_AcceptPayload.decode(reader, reader.uint32()),
-          };
+          message.update = { $case: "accept", accept: FriendshipUpdate_AcceptResponse.decode(reader, reader.uint32()) };
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.update = { $case: "reject", reject: FriendshipUpdate_RejectResponse.decode(reader, reader.uint32()) };
           continue;
         case 4:
           if (tag !== 34) {
             break;
           }
 
-          message.action = {
-            $case: "reject",
-            reject: UpsertFriendshipPayload_RejectPayload.decode(reader, reader.uint32()),
-          };
+          message.update = { $case: "delete", delete: FriendshipUpdate_DeleteResponse.decode(reader, reader.uint32()) };
           continue;
         case 5:
           if (tag !== 42) {
             break;
           }
 
-          message.action = {
-            $case: "delete",
-            delete: UpsertFriendshipPayload_DeletePayload.decode(reader, reader.uint32()),
-          };
+          message.update = { $case: "cancel", cancel: FriendshipUpdate_CancelResponse.decode(reader, reader.uint32()) };
           continue;
         case 6:
           if (tag !== 50) {
             break;
           }
 
-          message.action = {
-            $case: "cancel",
-            cancel: UpsertFriendshipPayload_CancelPayload.decode(reader, reader.uint32()),
-          };
+          message.update = { $case: "block", block: FriendshipUpdate_BlockResponse.decode(reader, reader.uint32()) };
           continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
@@ -849,111 +2412,110 @@ export namespace UpsertFriendshipPayload {
     return message;
   }
 
-  export function fromJSON(object: any): UpsertFriendshipPayload {
+  export function fromJSON(object: any): FriendshipUpdate {
     return {
-      action: isSet(object.request)
-        ? { $case: "request", request: UpsertFriendshipPayload_RequestPayload.fromJSON(object.request) }
+      update: isSet(object.request)
+        ? { $case: "request", request: FriendshipUpdate_RequestResponse.fromJSON(object.request) }
         : isSet(object.accept)
-        ? { $case: "accept", accept: UpsertFriendshipPayload_AcceptPayload.fromJSON(object.accept) }
+        ? { $case: "accept", accept: FriendshipUpdate_AcceptResponse.fromJSON(object.accept) }
         : isSet(object.reject)
-        ? { $case: "reject", reject: UpsertFriendshipPayload_RejectPayload.fromJSON(object.reject) }
+        ? { $case: "reject", reject: FriendshipUpdate_RejectResponse.fromJSON(object.reject) }
         : isSet(object.delete)
-        ? { $case: "delete", delete: UpsertFriendshipPayload_DeletePayload.fromJSON(object.delete) }
+        ? { $case: "delete", delete: FriendshipUpdate_DeleteResponse.fromJSON(object.delete) }
         : isSet(object.cancel)
-        ? { $case: "cancel", cancel: UpsertFriendshipPayload_CancelPayload.fromJSON(object.cancel) }
+        ? { $case: "cancel", cancel: FriendshipUpdate_CancelResponse.fromJSON(object.cancel) }
+        : isSet(object.block)
+        ? { $case: "block", block: FriendshipUpdate_BlockResponse.fromJSON(object.block) }
         : undefined,
     };
   }
 
-  export function toJSON(message: UpsertFriendshipPayload): unknown {
+  export function toJSON(message: FriendshipUpdate): unknown {
     const obj: any = {};
-    message.action?.$case === "request" &&
-      (obj.request = message.action?.request
-        ? UpsertFriendshipPayload_RequestPayload.toJSON(message.action?.request)
+    message.update?.$case === "request" &&
+      (obj.request = message.update?.request
+        ? FriendshipUpdate_RequestResponse.toJSON(message.update?.request)
         : undefined);
-    message.action?.$case === "accept" &&
-      (obj.accept = message.action?.accept
-        ? UpsertFriendshipPayload_AcceptPayload.toJSON(message.action?.accept)
+    message.update?.$case === "accept" &&
+      (obj.accept = message.update?.accept
+        ? FriendshipUpdate_AcceptResponse.toJSON(message.update?.accept)
         : undefined);
-    message.action?.$case === "reject" &&
-      (obj.reject = message.action?.reject
-        ? UpsertFriendshipPayload_RejectPayload.toJSON(message.action?.reject)
+    message.update?.$case === "reject" &&
+      (obj.reject = message.update?.reject
+        ? FriendshipUpdate_RejectResponse.toJSON(message.update?.reject)
         : undefined);
-    message.action?.$case === "delete" &&
-      (obj.delete = message.action?.delete
-        ? UpsertFriendshipPayload_DeletePayload.toJSON(message.action?.delete)
+    message.update?.$case === "delete" &&
+      (obj.delete = message.update?.delete
+        ? FriendshipUpdate_DeleteResponse.toJSON(message.update?.delete)
         : undefined);
-    message.action?.$case === "cancel" &&
-      (obj.cancel = message.action?.cancel
-        ? UpsertFriendshipPayload_CancelPayload.toJSON(message.action?.cancel)
+    message.update?.$case === "cancel" &&
+      (obj.cancel = message.update?.cancel
+        ? FriendshipUpdate_CancelResponse.toJSON(message.update?.cancel)
         : undefined);
+    message.update?.$case === "block" &&
+      (obj.block = message.update?.block ? FriendshipUpdate_BlockResponse.toJSON(message.update?.block) : undefined);
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<UpsertFriendshipPayload>, I>>(base?: I): UpsertFriendshipPayload {
-    return UpsertFriendshipPayload.fromPartial(base ?? {});
+  export function create<I extends Exact<DeepPartial<FriendshipUpdate>, I>>(base?: I): FriendshipUpdate {
+    return FriendshipUpdate.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<UpsertFriendshipPayload>, I>>(
-    object: I,
-  ): UpsertFriendshipPayload {
-    const message = createBaseUpsertFriendshipPayload();
-    if (object.action?.$case === "request" && object.action?.request !== undefined && object.action?.request !== null) {
-      message.action = {
+  export function fromPartial<I extends Exact<DeepPartial<FriendshipUpdate>, I>>(object: I): FriendshipUpdate {
+    const message = createBaseFriendshipUpdate();
+    if (object.update?.$case === "request" && object.update?.request !== undefined && object.update?.request !== null) {
+      message.update = {
         $case: "request",
-        request: UpsertFriendshipPayload_RequestPayload.fromPartial(object.action.request),
+        request: FriendshipUpdate_RequestResponse.fromPartial(object.update.request),
       };
     }
-    if (object.action?.$case === "accept" && object.action?.accept !== undefined && object.action?.accept !== null) {
-      message.action = {
-        $case: "accept",
-        accept: UpsertFriendshipPayload_AcceptPayload.fromPartial(object.action.accept),
-      };
+    if (object.update?.$case === "accept" && object.update?.accept !== undefined && object.update?.accept !== null) {
+      message.update = { $case: "accept", accept: FriendshipUpdate_AcceptResponse.fromPartial(object.update.accept) };
     }
-    if (object.action?.$case === "reject" && object.action?.reject !== undefined && object.action?.reject !== null) {
-      message.action = {
-        $case: "reject",
-        reject: UpsertFriendshipPayload_RejectPayload.fromPartial(object.action.reject),
-      };
+    if (object.update?.$case === "reject" && object.update?.reject !== undefined && object.update?.reject !== null) {
+      message.update = { $case: "reject", reject: FriendshipUpdate_RejectResponse.fromPartial(object.update.reject) };
     }
-    if (object.action?.$case === "delete" && object.action?.delete !== undefined && object.action?.delete !== null) {
-      message.action = {
-        $case: "delete",
-        delete: UpsertFriendshipPayload_DeletePayload.fromPartial(object.action.delete),
-      };
+    if (object.update?.$case === "delete" && object.update?.delete !== undefined && object.update?.delete !== null) {
+      message.update = { $case: "delete", delete: FriendshipUpdate_DeleteResponse.fromPartial(object.update.delete) };
     }
-    if (object.action?.$case === "cancel" && object.action?.cancel !== undefined && object.action?.cancel !== null) {
-      message.action = {
-        $case: "cancel",
-        cancel: UpsertFriendshipPayload_CancelPayload.fromPartial(object.action.cancel),
-      };
+    if (object.update?.$case === "cancel" && object.update?.cancel !== undefined && object.update?.cancel !== null) {
+      message.update = { $case: "cancel", cancel: FriendshipUpdate_CancelResponse.fromPartial(object.update.cancel) };
+    }
+    if (object.update?.$case === "block" && object.update?.block !== undefined && object.update?.block !== null) {
+      message.update = { $case: "block", block: FriendshipUpdate_BlockResponse.fromPartial(object.update.block) };
     }
     return message;
   }
 }
 
-function createBaseUpsertFriendshipPayload_RequestPayload(): UpsertFriendshipPayload_RequestPayload {
-  return { user: undefined, message: undefined };
+function createBaseFriendshipUpdate_RequestResponse(): FriendshipUpdate_RequestResponse {
+  return { friend: undefined, createdAt: 0, message: undefined, id: "" };
 }
 
-export namespace UpsertFriendshipPayload_RequestPayload {
+export namespace FriendshipUpdate_RequestResponse {
   export function encode(
-    message: UpsertFriendshipPayload_RequestPayload,
+    message: FriendshipUpdate_RequestResponse,
     writer: _m0.Writer = _m0.Writer.create(),
   ): _m0.Writer {
-    if (message.user !== undefined) {
-      User.encode(message.user, writer.uint32(10).fork()).ldelim();
+    if (message.friend !== undefined) {
+      FriendProfile.encode(message.friend, 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);
     }
+    if (message.id !== "") {
+      writer.uint32(34).string(message.id);
+    }
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): UpsertFriendshipPayload_RequestPayload {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): FriendshipUpdate_RequestResponse {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseUpsertFriendshipPayload_RequestPayload();
+    const message = createBaseFriendshipUpdate_RequestResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -962,7 +2524,14 @@ export namespace UpsertFriendshipPayload_RequestPayload {
             break;
           }
 
-          message.user = User.decode(reader, reader.uint32());
+          message.friend = FriendProfile.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.createdAt = longToNumber(reader.int64() as Long);
           continue;
         case 3:
           if (tag !== 26) {
@@ -971,6 +2540,13 @@ export namespace UpsertFriendshipPayload_RequestPayload {
 
           message.message = reader.string();
           continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.id = reader.string();
+          continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -980,43 +2556,51 @@ export namespace UpsertFriendshipPayload_RequestPayload {
     return message;
   }
 
-  export function fromJSON(object: any): UpsertFriendshipPayload_RequestPayload {
+  export function fromJSON(object: any): FriendshipUpdate_RequestResponse {
     return {
-      user: isSet(object.user) ? User.fromJSON(object.user) : undefined,
+      friend: isSet(object.friend) ? FriendProfile.fromJSON(object.friend) : undefined,
+      createdAt: isSet(object.createdAt) ? Number(object.createdAt) : 0,
       message: isSet(object.message) ? String(object.message) : undefined,
+      id: isSet(object.id) ? String(object.id) : "",
     };
   }
 
-  export function toJSON(message: UpsertFriendshipPayload_RequestPayload): unknown {
+  export function toJSON(message: FriendshipUpdate_RequestResponse): unknown {
     const obj: any = {};
-    message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
+    message.friend !== undefined && (obj.friend = message.friend ? FriendProfile.toJSON(message.friend) : undefined);
+    message.createdAt !== undefined && (obj.createdAt = Math.round(message.createdAt));
     message.message !== undefined && (obj.message = message.message);
+    message.id !== undefined && (obj.id = message.id);
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<UpsertFriendshipPayload_RequestPayload>, I>>(
+  export function create<I extends Exact<DeepPartial<FriendshipUpdate_RequestResponse>, I>>(
     base?: I,
-  ): UpsertFriendshipPayload_RequestPayload {
-    return UpsertFriendshipPayload_RequestPayload.fromPartial(base ?? {});
+  ): FriendshipUpdate_RequestResponse {
+    return FriendshipUpdate_RequestResponse.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<UpsertFriendshipPayload_RequestPayload>, I>>(
+  export function fromPartial<I extends Exact<DeepPartial<FriendshipUpdate_RequestResponse>, I>>(
     object: I,
-  ): UpsertFriendshipPayload_RequestPayload {
-    const message = createBaseUpsertFriendshipPayload_RequestPayload();
-    message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
+  ): FriendshipUpdate_RequestResponse {
+    const message = createBaseFriendshipUpdate_RequestResponse();
+    message.friend = (object.friend !== undefined && object.friend !== null)
+      ? FriendProfile.fromPartial(object.friend)
+      : undefined;
+    message.createdAt = object.createdAt ?? 0;
     message.message = object.message ?? undefined;
+    message.id = object.id ?? "";
     return message;
   }
 }
 
-function createBaseUpsertFriendshipPayload_AcceptPayload(): UpsertFriendshipPayload_AcceptPayload {
+function createBaseFriendshipUpdate_AcceptResponse(): FriendshipUpdate_AcceptResponse {
   return { user: undefined };
 }
 
-export namespace UpsertFriendshipPayload_AcceptPayload {
+export namespace FriendshipUpdate_AcceptResponse {
   export function encode(
-    message: UpsertFriendshipPayload_AcceptPayload,
+    message: FriendshipUpdate_AcceptResponse,
     writer: _m0.Writer = _m0.Writer.create(),
   ): _m0.Writer {
     if (message.user !== undefined) {
@@ -1025,10 +2609,10 @@ export namespace UpsertFriendshipPayload_AcceptPayload {
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): UpsertFriendshipPayload_AcceptPayload {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): FriendshipUpdate_AcceptResponse {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseUpsertFriendshipPayload_AcceptPayload();
+    const message = createBaseFriendshipUpdate_AcceptResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -1048,38 +2632,38 @@ export namespace UpsertFriendshipPayload_AcceptPayload {
     return message;
   }
 
-  export function fromJSON(object: any): UpsertFriendshipPayload_AcceptPayload {
+  export function fromJSON(object: any): FriendshipUpdate_AcceptResponse {
     return { user: isSet(object.user) ? User.fromJSON(object.user) : undefined };
   }
 
-  export function toJSON(message: UpsertFriendshipPayload_AcceptPayload): unknown {
+  export function toJSON(message: FriendshipUpdate_AcceptResponse): unknown {
     const obj: any = {};
     message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<UpsertFriendshipPayload_AcceptPayload>, I>>(
+  export function create<I extends Exact<DeepPartial<FriendshipUpdate_AcceptResponse>, I>>(
     base?: I,
-  ): UpsertFriendshipPayload_AcceptPayload {
-    return UpsertFriendshipPayload_AcceptPayload.fromPartial(base ?? {});
+  ): FriendshipUpdate_AcceptResponse {
+    return FriendshipUpdate_AcceptResponse.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<UpsertFriendshipPayload_AcceptPayload>, I>>(
+  export function fromPartial<I extends Exact<DeepPartial<FriendshipUpdate_AcceptResponse>, I>>(
     object: I,
-  ): UpsertFriendshipPayload_AcceptPayload {
-    const message = createBaseUpsertFriendshipPayload_AcceptPayload();
+  ): FriendshipUpdate_AcceptResponse {
+    const message = createBaseFriendshipUpdate_AcceptResponse();
     message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
     return message;
   }
 }
 
-function createBaseUpsertFriendshipPayload_RejectPayload(): UpsertFriendshipPayload_RejectPayload {
+function createBaseFriendshipUpdate_RejectResponse(): FriendshipUpdate_RejectResponse {
   return { user: undefined };
 }
 
-export namespace UpsertFriendshipPayload_RejectPayload {
+export namespace FriendshipUpdate_RejectResponse {
   export function encode(
-    message: UpsertFriendshipPayload_RejectPayload,
+    message: FriendshipUpdate_RejectResponse,
     writer: _m0.Writer = _m0.Writer.create(),
   ): _m0.Writer {
     if (message.user !== undefined) {
@@ -1088,10 +2672,10 @@ export namespace UpsertFriendshipPayload_RejectPayload {
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): UpsertFriendshipPayload_RejectPayload {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): FriendshipUpdate_RejectResponse {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseUpsertFriendshipPayload_RejectPayload();
+    const message = createBaseFriendshipUpdate_RejectResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -1111,38 +2695,38 @@ export namespace UpsertFriendshipPayload_RejectPayload {
     return message;
   }
 
-  export function fromJSON(object: any): UpsertFriendshipPayload_RejectPayload {
+  export function fromJSON(object: any): FriendshipUpdate_RejectResponse {
     return { user: isSet(object.user) ? User.fromJSON(object.user) : undefined };
   }
 
-  export function toJSON(message: UpsertFriendshipPayload_RejectPayload): unknown {
+  export function toJSON(message: FriendshipUpdate_RejectResponse): unknown {
     const obj: any = {};
     message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<UpsertFriendshipPayload_RejectPayload>, I>>(
+  export function create<I extends Exact<DeepPartial<FriendshipUpdate_RejectResponse>, I>>(
     base?: I,
-  ): UpsertFriendshipPayload_RejectPayload {
-    return UpsertFriendshipPayload_RejectPayload.fromPartial(base ?? {});
+  ): FriendshipUpdate_RejectResponse {
+    return FriendshipUpdate_RejectResponse.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<UpsertFriendshipPayload_RejectPayload>, I>>(
+  export function fromPartial<I extends Exact<DeepPartial<FriendshipUpdate_RejectResponse>, I>>(
     object: I,
-  ): UpsertFriendshipPayload_RejectPayload {
-    const message = createBaseUpsertFriendshipPayload_RejectPayload();
+  ): FriendshipUpdate_RejectResponse {
+    const message = createBaseFriendshipUpdate_RejectResponse();
     message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
     return message;
   }
 }
 
-function createBaseUpsertFriendshipPayload_DeletePayload(): UpsertFriendshipPayload_DeletePayload {
+function createBaseFriendshipUpdate_DeleteResponse(): FriendshipUpdate_DeleteResponse {
   return { user: undefined };
 }
 
-export namespace UpsertFriendshipPayload_DeletePayload {
+export namespace FriendshipUpdate_DeleteResponse {
   export function encode(
-    message: UpsertFriendshipPayload_DeletePayload,
+    message: FriendshipUpdate_DeleteResponse,
     writer: _m0.Writer = _m0.Writer.create(),
   ): _m0.Writer {
     if (message.user !== undefined) {
@@ -1151,10 +2735,10 @@ export namespace UpsertFriendshipPayload_DeletePayload {
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): UpsertFriendshipPayload_DeletePayload {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): FriendshipUpdate_DeleteResponse {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseUpsertFriendshipPayload_DeletePayload();
+    const message = createBaseFriendshipUpdate_DeleteResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -1174,38 +2758,38 @@ export namespace UpsertFriendshipPayload_DeletePayload {
     return message;
   }
 
-  export function fromJSON(object: any): UpsertFriendshipPayload_DeletePayload {
+  export function fromJSON(object: any): FriendshipUpdate_DeleteResponse {
     return { user: isSet(object.user) ? User.fromJSON(object.user) : undefined };
   }
 
-  export function toJSON(message: UpsertFriendshipPayload_DeletePayload): unknown {
+  export function toJSON(message: FriendshipUpdate_DeleteResponse): unknown {
     const obj: any = {};
     message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<UpsertFriendshipPayload_DeletePayload>, I>>(
+  export function create<I extends Exact<DeepPartial<FriendshipUpdate_DeleteResponse>, I>>(
     base?: I,
-  ): UpsertFriendshipPayload_DeletePayload {
-    return UpsertFriendshipPayload_DeletePayload.fromPartial(base ?? {});
+  ): FriendshipUpdate_DeleteResponse {
+    return FriendshipUpdate_DeleteResponse.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<UpsertFriendshipPayload_DeletePayload>, I>>(
+  export function fromPartial<I extends Exact<DeepPartial<FriendshipUpdate_DeleteResponse>, I>>(
     object: I,
-  ): UpsertFriendshipPayload_DeletePayload {
-    const message = createBaseUpsertFriendshipPayload_DeletePayload();
+  ): FriendshipUpdate_DeleteResponse {
+    const message = createBaseFriendshipUpdate_DeleteResponse();
     message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
     return message;
   }
 }
 
-function createBaseUpsertFriendshipPayload_CancelPayload(): UpsertFriendshipPayload_CancelPayload {
+function createBaseFriendshipUpdate_CancelResponse(): FriendshipUpdate_CancelResponse {
   return { user: undefined };
 }
 
-export namespace UpsertFriendshipPayload_CancelPayload {
+export namespace FriendshipUpdate_CancelResponse {
   export function encode(
-    message: UpsertFriendshipPayload_CancelPayload,
+    message: FriendshipUpdate_CancelResponse,
     writer: _m0.Writer = _m0.Writer.create(),
   ): _m0.Writer {
     if (message.user !== undefined) {
@@ -1214,10 +2798,10 @@ export namespace UpsertFriendshipPayload_CancelPayload {
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): UpsertFriendshipPayload_CancelPayload {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): FriendshipUpdate_CancelResponse {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseUpsertFriendshipPayload_CancelPayload();
+    const message = createBaseFriendshipUpdate_CancelResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -1237,50 +2821,50 @@ export namespace UpsertFriendshipPayload_CancelPayload {
     return message;
   }
 
-  export function fromJSON(object: any): UpsertFriendshipPayload_CancelPayload {
+  export function fromJSON(object: any): FriendshipUpdate_CancelResponse {
     return { user: isSet(object.user) ? User.fromJSON(object.user) : undefined };
   }
 
-  export function toJSON(message: UpsertFriendshipPayload_CancelPayload): unknown {
+  export function toJSON(message: FriendshipUpdate_CancelResponse): unknown {
     const obj: any = {};
     message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<UpsertFriendshipPayload_CancelPayload>, I>>(
+  export function create<I extends Exact<DeepPartial<FriendshipUpdate_CancelResponse>, I>>(
     base?: I,
-  ): UpsertFriendshipPayload_CancelPayload {
-    return UpsertFriendshipPayload_CancelPayload.fromPartial(base ?? {});
+  ): FriendshipUpdate_CancelResponse {
+    return FriendshipUpdate_CancelResponse.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<UpsertFriendshipPayload_CancelPayload>, I>>(
+  export function fromPartial<I extends Exact<DeepPartial<FriendshipUpdate_CancelResponse>, I>>(
     object: I,
-  ): UpsertFriendshipPayload_CancelPayload {
-    const message = createBaseUpsertFriendshipPayload_CancelPayload();
+  ): FriendshipUpdate_CancelResponse {
+    const message = createBaseFriendshipUpdate_CancelResponse();
     message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
     return message;
   }
 }
 
-function createBaseGetMutualFriendsPayload(): GetMutualFriendsPayload {
-  return { user: undefined, pagination: undefined };
+function createBaseFriendshipUpdate_BlockResponse(): FriendshipUpdate_BlockResponse {
+  return { user: undefined };
 }
 
-export namespace GetMutualFriendsPayload {
-  export function encode(message: GetMutualFriendsPayload, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export namespace FriendshipUpdate_BlockResponse {
+  export function encode(
+    message: FriendshipUpdate_BlockResponse,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
     if (message.user !== undefined) {
       User.encode(message.user, writer.uint32(10).fork()).ldelim();
     }
-    if (message.pagination !== undefined) {
-      Pagination.encode(message.pagination, writer.uint32(18).fork()).ldelim();
-    }
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): GetMutualFriendsPayload {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): FriendshipUpdate_BlockResponse {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseGetMutualFriendsPayload();
+    const message = createBaseFriendshipUpdate_BlockResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -1291,13 +2875,6 @@ export namespace GetMutualFriendsPayload {
 
           message.user = User.decode(reader, reader.uint32());
           continue;
-        case 2:
-          if (tag !== 18) {
-            break;
-          }
-
-          message.pagination = Pagination.decode(reader, reader.uint32());
-          continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -1307,72 +2884,66 @@ export namespace GetMutualFriendsPayload {
     return message;
   }
 
-  export function fromJSON(object: any): GetMutualFriendsPayload {
-    return {
-      user: isSet(object.user) ? User.fromJSON(object.user) : undefined,
-      pagination: isSet(object.pagination) ? Pagination.fromJSON(object.pagination) : undefined,
-    };
+  export function fromJSON(object: any): FriendshipUpdate_BlockResponse {
+    return { user: isSet(object.user) ? User.fromJSON(object.user) : undefined };
   }
 
-  export function toJSON(message: GetMutualFriendsPayload): unknown {
+  export function toJSON(message: FriendshipUpdate_BlockResponse): unknown {
     const obj: any = {};
     message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
-    message.pagination !== undefined &&
-      (obj.pagination = message.pagination ? Pagination.toJSON(message.pagination) : undefined);
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<GetMutualFriendsPayload>, I>>(base?: I): GetMutualFriendsPayload {
-    return GetMutualFriendsPayload.fromPartial(base ?? {});
+  export function create<I extends Exact<DeepPartial<FriendshipUpdate_BlockResponse>, I>>(
+    base?: I,
+  ): FriendshipUpdate_BlockResponse {
+    return FriendshipUpdate_BlockResponse.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<GetMutualFriendsPayload>, I>>(
+  export function fromPartial<I extends Exact<DeepPartial<FriendshipUpdate_BlockResponse>, I>>(
     object: I,
-  ): GetMutualFriendsPayload {
-    const message = createBaseGetMutualFriendsPayload();
+  ): FriendshipUpdate_BlockResponse {
+    const message = createBaseFriendshipUpdate_BlockResponse();
     message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
-    message.pagination = (object.pagination !== undefined && object.pagination !== null)
-      ? Pagination.fromPartial(object.pagination)
-      : undefined;
     return message;
   }
 }
 
-function createBasePaginatedResponse(): PaginatedResponse {
-  return { total: 0, page: 0 };
+function createBaseFriendConnectivityUpdate(): FriendConnectivityUpdate {
+  return { friend: undefined, status: 0 };
 }
 
-export namespace PaginatedResponse {
-  export function encode(message: PaginatedResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.total !== 0) {
-      writer.uint32(8).int32(message.total);
+export namespace FriendConnectivityUpdate {
+  export function encode(message: FriendConnectivityUpdate, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.friend !== undefined) {
+      FriendProfile.encode(message.friend, writer.uint32(10).fork()).ldelim();
     }
-    if (message.page !== 0) {
-      writer.uint32(16).int32(message.page);
+    if (message.status !== 0) {
+      writer.uint32(16).int32(message.status);
     }
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): PaginatedResponse {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): FriendConnectivityUpdate {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBasePaginatedResponse();
+    const message = createBaseFriendConnectivityUpdate();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          if (tag !== 8) {
+          if (tag !== 10) {
             break;
           }
 
-          message.total = reader.int32();
+          message.friend = FriendProfile.decode(reader, reader.uint32());
           continue;
         case 2:
           if (tag !== 16) {
             break;
           }
 
-          message.page = reader.int32();
+          message.status = reader.int32() as any;
           continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
@@ -1383,67 +2954,63 @@ export namespace PaginatedResponse {
     return message;
   }
 
-  export function fromJSON(object: any): PaginatedResponse {
+  export function fromJSON(object: any): FriendConnectivityUpdate {
     return {
-      total: isSet(object.total) ? Number(object.total) : 0,
-      page: isSet(object.page) ? Number(object.page) : 0,
+      friend: isSet(object.friend) ? FriendProfile.fromJSON(object.friend) : undefined,
+      status: isSet(object.status) ? connectivityStatusFromJSON(object.status) : 0,
     };
   }
 
-  export function toJSON(message: PaginatedResponse): unknown {
+  export function toJSON(message: FriendConnectivityUpdate): unknown {
     const obj: any = {};
-    message.total !== undefined && (obj.total = Math.round(message.total));
-    message.page !== undefined && (obj.page = Math.round(message.page));
+    message.friend !== undefined && (obj.friend = message.friend ? FriendProfile.toJSON(message.friend) : undefined);
+    message.status !== undefined && (obj.status = connectivityStatusToJSON(message.status));
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<PaginatedResponse>, I>>(base?: I): PaginatedResponse {
-    return PaginatedResponse.fromPartial(base ?? {});
+  export function create<I extends Exact<DeepPartial<FriendConnectivityUpdate>, I>>(
+    base?: I,
+  ): FriendConnectivityUpdate {
+    return FriendConnectivityUpdate.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<PaginatedResponse>, I>>(object: I): PaginatedResponse {
-    const message = createBasePaginatedResponse();
-    message.total = object.total ?? 0;
-    message.page = object.page ?? 0;
+  export function fromPartial<I extends Exact<DeepPartial<FriendConnectivityUpdate>, I>>(
+    object: I,
+  ): FriendConnectivityUpdate {
+    const message = createBaseFriendConnectivityUpdate();
+    message.friend = (object.friend !== undefined && object.friend !== null)
+      ? FriendProfile.fromPartial(object.friend)
+      : undefined;
+    message.status = object.status ?? 0;
     return message;
   }
 }
 
-function createBasePaginatedUsersResponse(): PaginatedUsersResponse {
-  return { users: [], paginationData: undefined };
+function createBaseGetFriendshipStatusPayload(): GetFriendshipStatusPayload {
+  return { user: undefined };
 }
 
-export namespace PaginatedUsersResponse {
-  export function encode(message: PaginatedUsersResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    for (const v of message.users) {
-      User.encode(v!, writer.uint32(10).fork()).ldelim();
-    }
-    if (message.paginationData !== undefined) {
-      PaginatedResponse.encode(message.paginationData, writer.uint32(18).fork()).ldelim();
+export namespace GetFriendshipStatusPayload {
+  export function encode(message: GetFriendshipStatusPayload, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.user !== undefined) {
+      User.encode(message.user, writer.uint32(10).fork()).ldelim();
     }
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): PaginatedUsersResponse {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): GetFriendshipStatusPayload {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBasePaginatedUsersResponse();
+    const message = createBaseGetFriendshipStatusPayload();
     while (reader.pos < end) {
       const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1:
-          if (tag !== 10) {
-            break;
-          }
-
-          message.users.push(User.decode(reader, reader.uint32()));
-          continue;
-        case 2:
-          if (tag !== 18) {
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
             break;
           }
 
-          message.paginationData = PaginatedResponse.decode(reader, reader.uint32());
+          message.user = User.decode(reader, reader.uint32());
           continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
@@ -1454,68 +3021,52 @@ export namespace PaginatedUsersResponse {
     return message;
   }
 
-  export function fromJSON(object: any): PaginatedUsersResponse {
-    return {
-      users: Array.isArray(object?.users) ? object.users.map((e: any) => User.fromJSON(e)) : [],
-      paginationData: isSet(object.paginationData) ? PaginatedResponse.fromJSON(object.paginationData) : undefined,
-    };
+  export function fromJSON(object: any): GetFriendshipStatusPayload {
+    return { user: isSet(object.user) ? User.fromJSON(object.user) : undefined };
   }
 
-  export function toJSON(message: PaginatedUsersResponse): unknown {
+  export function toJSON(message: GetFriendshipStatusPayload): unknown {
     const obj: any = {};
-    if (message.users) {
-      obj.users = message.users.map((e) => e ? User.toJSON(e) : undefined);
-    } else {
-      obj.users = [];
-    }
-    message.paginationData !== undefined &&
-      (obj.paginationData = message.paginationData ? PaginatedResponse.toJSON(message.paginationData) : undefined);
+    message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<PaginatedUsersResponse>, I>>(base?: I): PaginatedUsersResponse {
-    return PaginatedUsersResponse.fromPartial(base ?? {});
+  export function create<I extends Exact<DeepPartial<GetFriendshipStatusPayload>, I>>(
+    base?: I,
+  ): GetFriendshipStatusPayload {
+    return GetFriendshipStatusPayload.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<PaginatedUsersResponse>, I>>(
+  export function fromPartial<I extends Exact<DeepPartial<GetFriendshipStatusPayload>, I>>(
     object: I,
-  ): PaginatedUsersResponse {
-    const message = createBasePaginatedUsersResponse();
-    message.users = object.users?.map((e) => User.fromPartial(e)) || [];
-    message.paginationData = (object.paginationData !== undefined && object.paginationData !== null)
-      ? PaginatedResponse.fromPartial(object.paginationData)
-      : undefined;
+  ): GetFriendshipStatusPayload {
+    const message = createBaseGetFriendshipStatusPayload();
+    message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
     return message;
   }
 }
 
-function createBasePaginatedFriendshipRequestsResponse(): PaginatedFriendshipRequestsResponse {
-  return { response: undefined, paginationData: undefined };
+function createBaseGetFriendshipStatusResponse(): GetFriendshipStatusResponse {
+  return { response: undefined };
 }
 
-export namespace PaginatedFriendshipRequestsResponse {
-  export function encode(
-    message: PaginatedFriendshipRequestsResponse,
-    writer: _m0.Writer = _m0.Writer.create(),
-  ): _m0.Writer {
+export namespace GetFriendshipStatusResponse {
+  export function encode(message: GetFriendshipStatusResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     switch (message.response?.$case) {
-      case "requests":
-        FriendshipRequests.encode(message.response.requests, writer.uint32(10).fork()).ldelim();
+      case "accepted":
+        GetFriendshipStatusResponse_Ok.encode(message.response.accepted, writer.uint32(10).fork()).ldelim();
         break;
       case "internalServerError":
         InternalServerError.encode(message.response.internalServerError, writer.uint32(18).fork()).ldelim();
         break;
     }
-    if (message.paginationData !== undefined) {
-      PaginatedResponse.encode(message.paginationData, writer.uint32(26).fork()).ldelim();
-    }
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): PaginatedFriendshipRequestsResponse {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): GetFriendshipStatusResponse {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBasePaginatedFriendshipRequestsResponse();
+    const message = createBaseGetFriendshipStatusResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -1524,7 +3075,10 @@ export namespace PaginatedFriendshipRequestsResponse {
             break;
           }
 
-          message.response = { $case: "requests", requests: FriendshipRequests.decode(reader, reader.uint32()) };
+          message.response = {
+            $case: "accepted",
+            accepted: GetFriendshipStatusResponse_Ok.decode(reader, reader.uint32()),
+          };
           continue;
         case 2:
           if (tag !== 18) {
@@ -1536,13 +3090,6 @@ export namespace PaginatedFriendshipRequestsResponse {
             internalServerError: InternalServerError.decode(reader, reader.uint32()),
           };
           continue;
-        case 3:
-          if (tag !== 26) {
-            break;
-          }
-
-          message.paginationData = PaginatedResponse.decode(reader, reader.uint32());
-          continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -1552,49 +3099,51 @@ export namespace PaginatedFriendshipRequestsResponse {
     return message;
   }
 
-  export function fromJSON(object: any): PaginatedFriendshipRequestsResponse {
+  export function fromJSON(object: any): GetFriendshipStatusResponse {
     return {
-      response: isSet(object.requests)
-        ? { $case: "requests", requests: FriendshipRequests.fromJSON(object.requests) }
+      response: isSet(object.accepted)
+        ? { $case: "accepted", accepted: GetFriendshipStatusResponse_Ok.fromJSON(object.accepted) }
         : isSet(object.internalServerError)
         ? {
           $case: "internalServerError",
           internalServerError: InternalServerError.fromJSON(object.internalServerError),
         }
         : undefined,
-      paginationData: isSet(object.paginationData) ? PaginatedResponse.fromJSON(object.paginationData) : undefined,
     };
   }
 
-  export function toJSON(message: PaginatedFriendshipRequestsResponse): unknown {
+  export function toJSON(message: GetFriendshipStatusResponse): unknown {
     const obj: any = {};
-    message.response?.$case === "requests" &&
-      (obj.requests = message.response?.requests ? FriendshipRequests.toJSON(message.response?.requests) : undefined);
+    message.response?.$case === "accepted" &&
+      (obj.accepted = message.response?.accepted
+        ? GetFriendshipStatusResponse_Ok.toJSON(message.response?.accepted)
+        : undefined);
     message.response?.$case === "internalServerError" &&
       (obj.internalServerError = message.response?.internalServerError
         ? InternalServerError.toJSON(message.response?.internalServerError)
         : undefined);
-    message.paginationData !== undefined &&
-      (obj.paginationData = message.paginationData ? PaginatedResponse.toJSON(message.paginationData) : undefined);
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<PaginatedFriendshipRequestsResponse>, I>>(
+  export function create<I extends Exact<DeepPartial<GetFriendshipStatusResponse>, I>>(
     base?: I,
-  ): PaginatedFriendshipRequestsResponse {
-    return PaginatedFriendshipRequestsResponse.fromPartial(base ?? {});
+  ): GetFriendshipStatusResponse {
+    return GetFriendshipStatusResponse.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<PaginatedFriendshipRequestsResponse>, I>>(
+  export function fromPartial<I extends Exact<DeepPartial<GetFriendshipStatusResponse>, I>>(
     object: I,
-  ): PaginatedFriendshipRequestsResponse {
-    const message = createBasePaginatedFriendshipRequestsResponse();
+  ): GetFriendshipStatusResponse {
+    const message = createBaseGetFriendshipStatusResponse();
     if (
-      object.response?.$case === "requests" &&
-      object.response?.requests !== undefined &&
-      object.response?.requests !== null
+      object.response?.$case === "accepted" &&
+      object.response?.accepted !== undefined &&
+      object.response?.accepted !== null
     ) {
-      message.response = { $case: "requests", requests: FriendshipRequests.fromPartial(object.response.requests) };
+      message.response = {
+        $case: "accepted",
+        accepted: GetFriendshipStatusResponse_Ok.fromPartial(object.response.accepted),
+      };
     }
     if (
       object.response?.$case === "internalServerError" &&
@@ -1606,69 +3155,48 @@ export namespace PaginatedFriendshipRequestsResponse {
         internalServerError: InternalServerError.fromPartial(object.response.internalServerError),
       };
     }
-    message.paginationData = (object.paginationData !== undefined && object.paginationData !== null)
-      ? PaginatedResponse.fromPartial(object.paginationData)
-      : undefined;
     return message;
   }
 }
 
-function createBaseUpsertFriendshipResponse(): UpsertFriendshipResponse {
-  return { response: undefined };
+function createBaseGetFriendshipStatusResponse_Ok(): GetFriendshipStatusResponse_Ok {
+  return { status: 0, message: undefined };
 }
 
-export namespace UpsertFriendshipResponse {
-  export function encode(message: UpsertFriendshipResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    switch (message.response?.$case) {
-      case "accepted":
-        UpsertFriendshipResponse_Accepted.encode(message.response.accepted, writer.uint32(10).fork()).ldelim();
-        break;
-      case "invalidFriendshipAction":
-        InvalidFriendshipAction.encode(message.response.invalidFriendshipAction, writer.uint32(18).fork()).ldelim();
-        break;
-      case "internalServerError":
-        InternalServerError.encode(message.response.internalServerError, writer.uint32(26).fork()).ldelim();
-        break;
+export namespace GetFriendshipStatusResponse_Ok {
+  export function encode(
+    message: GetFriendshipStatusResponse_Ok,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    if (message.status !== 0) {
+      writer.uint32(8).int32(message.status);
+    }
+    if (message.message !== undefined) {
+      writer.uint32(18).string(message.message);
     }
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): UpsertFriendshipResponse {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): GetFriendshipStatusResponse_Ok {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseUpsertFriendshipResponse();
+    const message = createBaseGetFriendshipStatusResponse_Ok();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          if (tag !== 10) {
+          if (tag !== 8) {
             break;
           }
 
-          message.response = {
-            $case: "accepted",
-            accepted: UpsertFriendshipResponse_Accepted.decode(reader, reader.uint32()),
-          };
+          message.status = reader.int32() as any;
           continue;
         case 2:
           if (tag !== 18) {
             break;
           }
 
-          message.response = {
-            $case: "invalidFriendshipAction",
-            invalidFriendshipAction: InvalidFriendshipAction.decode(reader, reader.uint32()),
-          };
-          continue;
-        case 3:
-          if (tag !== 26) {
-            break;
-          }
-
-          message.response = {
-            $case: "internalServerError",
-            internalServerError: InternalServerError.decode(reader, reader.uint32()),
-          };
+          message.message = reader.string();
           continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
@@ -1679,107 +3207,52 @@ export namespace UpsertFriendshipResponse {
     return message;
   }
 
-  export function fromJSON(object: any): UpsertFriendshipResponse {
+  export function fromJSON(object: any): GetFriendshipStatusResponse_Ok {
     return {
-      response: isSet(object.accepted)
-        ? { $case: "accepted", accepted: UpsertFriendshipResponse_Accepted.fromJSON(object.accepted) }
-        : isSet(object.invalidFriendshipAction)
-        ? {
-          $case: "invalidFriendshipAction",
-          invalidFriendshipAction: InvalidFriendshipAction.fromJSON(object.invalidFriendshipAction),
-        }
-        : isSet(object.internalServerError)
-        ? {
-          $case: "internalServerError",
-          internalServerError: InternalServerError.fromJSON(object.internalServerError),
-        }
-        : undefined,
+      status: isSet(object.status) ? friendshipStatusFromJSON(object.status) : 0,
+      message: isSet(object.message) ? String(object.message) : undefined,
     };
   }
 
-  export function toJSON(message: UpsertFriendshipResponse): unknown {
+  export function toJSON(message: GetFriendshipStatusResponse_Ok): unknown {
     const obj: any = {};
-    message.response?.$case === "accepted" &&
-      (obj.accepted = message.response?.accepted
-        ? UpsertFriendshipResponse_Accepted.toJSON(message.response?.accepted)
-        : undefined);
-    message.response?.$case === "invalidFriendshipAction" &&
-      (obj.invalidFriendshipAction = message.response?.invalidFriendshipAction
-        ? InvalidFriendshipAction.toJSON(message.response?.invalidFriendshipAction)
-        : undefined);
-    message.response?.$case === "internalServerError" &&
-      (obj.internalServerError = message.response?.internalServerError
-        ? InternalServerError.toJSON(message.response?.internalServerError)
-        : undefined);
+    message.status !== undefined && (obj.status = friendshipStatusToJSON(message.status));
+    message.message !== undefined && (obj.message = message.message);
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<UpsertFriendshipResponse>, I>>(
+  export function create<I extends Exact<DeepPartial<GetFriendshipStatusResponse_Ok>, I>>(
     base?: I,
-  ): UpsertFriendshipResponse {
-    return UpsertFriendshipResponse.fromPartial(base ?? {});
+  ): GetFriendshipStatusResponse_Ok {
+    return GetFriendshipStatusResponse_Ok.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<UpsertFriendshipResponse>, I>>(
+  export function fromPartial<I extends Exact<DeepPartial<GetFriendshipStatusResponse_Ok>, I>>(
     object: I,
-  ): UpsertFriendshipResponse {
-    const message = createBaseUpsertFriendshipResponse();
-    if (
-      object.response?.$case === "accepted" &&
-      object.response?.accepted !== undefined &&
-      object.response?.accepted !== null
-    ) {
-      message.response = {
-        $case: "accepted",
-        accepted: UpsertFriendshipResponse_Accepted.fromPartial(object.response.accepted),
-      };
-    }
-    if (
-      object.response?.$case === "invalidFriendshipAction" &&
-      object.response?.invalidFriendshipAction !== undefined &&
-      object.response?.invalidFriendshipAction !== null
-    ) {
-      message.response = {
-        $case: "invalidFriendshipAction",
-        invalidFriendshipAction: InvalidFriendshipAction.fromPartial(object.response.invalidFriendshipAction),
-      };
-    }
-    if (
-      object.response?.$case === "internalServerError" &&
-      object.response?.internalServerError !== undefined &&
-      object.response?.internalServerError !== null
-    ) {
-      message.response = {
-        $case: "internalServerError",
-        internalServerError: InternalServerError.fromPartial(object.response.internalServerError),
-      };
-    }
+  ): GetFriendshipStatusResponse_Ok {
+    const message = createBaseGetFriendshipStatusResponse_Ok();
+    message.status = object.status ?? 0;
+    message.message = object.message ?? undefined;
     return message;
   }
 }
 
-function createBaseUpsertFriendshipResponse_Accepted(): UpsertFriendshipResponse_Accepted {
-  return { id: "", createdAt: 0 };
+function createBaseBlockUserPayload(): BlockUserPayload {
+  return { user: undefined };
 }
 
-export namespace UpsertFriendshipResponse_Accepted {
-  export function encode(
-    message: UpsertFriendshipResponse_Accepted,
-    writer: _m0.Writer = _m0.Writer.create(),
-  ): _m0.Writer {
-    if (message.id !== "") {
-      writer.uint32(10).string(message.id);
-    }
-    if (message.createdAt !== 0) {
-      writer.uint32(16).int64(message.createdAt);
+export namespace BlockUserPayload {
+  export function encode(message: BlockUserPayload, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.user !== undefined) {
+      User.encode(message.user, writer.uint32(10).fork()).ldelim();
     }
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): UpsertFriendshipResponse_Accepted {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): BlockUserPayload {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseUpsertFriendshipResponse_Accepted();
+    const message = createBaseBlockUserPayload();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -1788,14 +3261,7 @@ export namespace UpsertFriendshipResponse_Accepted {
             break;
           }
 
-          message.id = reader.string();
-          continue;
-        case 2:
-          if (tag !== 16) {
-            break;
-          }
-
-          message.createdAt = longToNumber(reader.int64() as Long);
+          message.user = User.decode(reader, reader.uint32());
           continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
@@ -1806,66 +3272,54 @@ export namespace UpsertFriendshipResponse_Accepted {
     return message;
   }
 
-  export function fromJSON(object: any): UpsertFriendshipResponse_Accepted {
-    return {
-      id: isSet(object.id) ? String(object.id) : "",
-      createdAt: isSet(object.createdAt) ? Number(object.createdAt) : 0,
-    };
+  export function fromJSON(object: any): BlockUserPayload {
+    return { user: isSet(object.user) ? User.fromJSON(object.user) : undefined };
   }
 
-  export function toJSON(message: UpsertFriendshipResponse_Accepted): unknown {
+  export function toJSON(message: BlockUserPayload): unknown {
     const obj: any = {};
-    message.id !== undefined && (obj.id = message.id);
-    message.createdAt !== undefined && (obj.createdAt = Math.round(message.createdAt));
+    message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<UpsertFriendshipResponse_Accepted>, I>>(
-    base?: I,
-  ): UpsertFriendshipResponse_Accepted {
-    return UpsertFriendshipResponse_Accepted.fromPartial(base ?? {});
+  export function create<I extends Exact<DeepPartial<BlockUserPayload>, I>>(base?: I): BlockUserPayload {
+    return BlockUserPayload.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<UpsertFriendshipResponse_Accepted>, I>>(
-    object: I,
-  ): UpsertFriendshipResponse_Accepted {
-    const message = createBaseUpsertFriendshipResponse_Accepted();
-    message.id = object.id ?? "";
-    message.createdAt = object.createdAt ?? 0;
+  export function fromPartial<I extends Exact<DeepPartial<BlockUserPayload>, I>>(object: I): BlockUserPayload {
+    const message = createBaseBlockUserPayload();
+    message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
     return message;
   }
 }
 
-function createBaseFriendshipUpdate(): FriendshipUpdate {
-  return { update: undefined };
+function createBaseBlockUserResponse(): BlockUserResponse {
+  return { response: undefined };
 }
 
-export namespace FriendshipUpdate {
-  export function encode(message: FriendshipUpdate, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    switch (message.update?.$case) {
-      case "request":
-        FriendshipRequestResponse.encode(message.update.request, writer.uint32(10).fork()).ldelim();
-        break;
-      case "accept":
-        FriendshipUpdate_AcceptResponse.encode(message.update.accept, writer.uint32(18).fork()).ldelim();
+export namespace BlockUserResponse {
+  export function encode(message: BlockUserResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    switch (message.response?.$case) {
+      case "ok":
+        BlockUserResponse_Ok.encode(message.response.ok, writer.uint32(10).fork()).ldelim();
         break;
-      case "reject":
-        FriendshipUpdate_RejectResponse.encode(message.update.reject, writer.uint32(26).fork()).ldelim();
+      case "internalServerError":
+        InternalServerError.encode(message.response.internalServerError, writer.uint32(18).fork()).ldelim();
         break;
-      case "delete":
-        FriendshipUpdate_DeleteResponse.encode(message.update.delete, writer.uint32(34).fork()).ldelim();
+      case "invalidRequest":
+        InvalidRequest.encode(message.response.invalidRequest, writer.uint32(26).fork()).ldelim();
         break;
-      case "cancel":
-        FriendshipUpdate_CancelResponse.encode(message.update.cancel, writer.uint32(42).fork()).ldelim();
+      case "profileNotFound":
+        ProfileNotFound.encode(message.response.profileNotFound, writer.uint32(34).fork()).ldelim();
         break;
     }
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): FriendshipUpdate {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): BlockUserResponse {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseFriendshipUpdate();
+    const message = createBaseBlockUserResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -1874,35 +3328,37 @@ export namespace FriendshipUpdate {
             break;
           }
 
-          message.update = { $case: "request", request: FriendshipRequestResponse.decode(reader, reader.uint32()) };
+          message.response = { $case: "ok", ok: BlockUserResponse_Ok.decode(reader, reader.uint32()) };
           continue;
         case 2:
           if (tag !== 18) {
             break;
           }
 
-          message.update = { $case: "accept", accept: FriendshipUpdate_AcceptResponse.decode(reader, reader.uint32()) };
+          message.response = {
+            $case: "internalServerError",
+            internalServerError: InternalServerError.decode(reader, reader.uint32()),
+          };
           continue;
         case 3:
           if (tag !== 26) {
             break;
           }
 
-          message.update = { $case: "reject", reject: FriendshipUpdate_RejectResponse.decode(reader, reader.uint32()) };
+          message.response = {
+            $case: "invalidRequest",
+            invalidRequest: InvalidRequest.decode(reader, reader.uint32()),
+          };
           continue;
         case 4:
           if (tag !== 34) {
             break;
           }
 
-          message.update = { $case: "delete", delete: FriendshipUpdate_DeleteResponse.decode(reader, reader.uint32()) };
-          continue;
-        case 5:
-          if (tag !== 42) {
-            break;
-          }
-
-          message.update = { $case: "cancel", cancel: FriendshipUpdate_CancelResponse.decode(reader, reader.uint32()) };
+          message.response = {
+            $case: "profileNotFound",
+            profileNotFound: ProfileNotFound.decode(reader, reader.uint32()),
+          };
           continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
@@ -1913,89 +3369,160 @@ export namespace FriendshipUpdate {
     return message;
   }
 
-  export function fromJSON(object: any): FriendshipUpdate {
+  export function fromJSON(object: any): BlockUserResponse {
     return {
-      update: isSet(object.request)
-        ? { $case: "request", request: FriendshipRequestResponse.fromJSON(object.request) }
-        : isSet(object.accept)
-        ? { $case: "accept", accept: FriendshipUpdate_AcceptResponse.fromJSON(object.accept) }
-        : isSet(object.reject)
-        ? { $case: "reject", reject: FriendshipUpdate_RejectResponse.fromJSON(object.reject) }
-        : isSet(object.delete)
-        ? { $case: "delete", delete: FriendshipUpdate_DeleteResponse.fromJSON(object.delete) }
-        : isSet(object.cancel)
-        ? { $case: "cancel", cancel: FriendshipUpdate_CancelResponse.fromJSON(object.cancel) }
+      response: isSet(object.ok)
+        ? { $case: "ok", ok: BlockUserResponse_Ok.fromJSON(object.ok) }
+        : isSet(object.internalServerError)
+        ? {
+          $case: "internalServerError",
+          internalServerError: InternalServerError.fromJSON(object.internalServerError),
+        }
+        : isSet(object.invalidRequest)
+        ? { $case: "invalidRequest", invalidRequest: InvalidRequest.fromJSON(object.invalidRequest) }
+        : isSet(object.profileNotFound)
+        ? { $case: "profileNotFound", profileNotFound: ProfileNotFound.fromJSON(object.profileNotFound) }
         : undefined,
     };
   }
 
-  export function toJSON(message: FriendshipUpdate): unknown {
+  export function toJSON(message: BlockUserResponse): unknown {
     const obj: any = {};
-    message.update?.$case === "request" &&
-      (obj.request = message.update?.request ? FriendshipRequestResponse.toJSON(message.update?.request) : undefined);
-    message.update?.$case === "accept" &&
-      (obj.accept = message.update?.accept
-        ? FriendshipUpdate_AcceptResponse.toJSON(message.update?.accept)
-        : undefined);
-    message.update?.$case === "reject" &&
-      (obj.reject = message.update?.reject
-        ? FriendshipUpdate_RejectResponse.toJSON(message.update?.reject)
+    message.response?.$case === "ok" &&
+      (obj.ok = message.response?.ok ? BlockUserResponse_Ok.toJSON(message.response?.ok) : undefined);
+    message.response?.$case === "internalServerError" &&
+      (obj.internalServerError = message.response?.internalServerError
+        ? InternalServerError.toJSON(message.response?.internalServerError)
         : undefined);
-    message.update?.$case === "delete" &&
-      (obj.delete = message.update?.delete
-        ? FriendshipUpdate_DeleteResponse.toJSON(message.update?.delete)
+    message.response?.$case === "invalidRequest" &&
+      (obj.invalidRequest = message.response?.invalidRequest
+        ? InvalidRequest.toJSON(message.response?.invalidRequest)
         : undefined);
-    message.update?.$case === "cancel" &&
-      (obj.cancel = message.update?.cancel
-        ? FriendshipUpdate_CancelResponse.toJSON(message.update?.cancel)
+    message.response?.$case === "profileNotFound" &&
+      (obj.profileNotFound = message.response?.profileNotFound
+        ? ProfileNotFound.toJSON(message.response?.profileNotFound)
         : undefined);
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<FriendshipUpdate>, I>>(base?: I): FriendshipUpdate {
-    return FriendshipUpdate.fromPartial(base ?? {});
+  export function create<I extends Exact<DeepPartial<BlockUserResponse>, I>>(base?: I): BlockUserResponse {
+    return BlockUserResponse.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<FriendshipUpdate>, I>>(object: I): FriendshipUpdate {
-    const message = createBaseFriendshipUpdate();
-    if (object.update?.$case === "request" && object.update?.request !== undefined && object.update?.request !== null) {
-      message.update = { $case: "request", request: FriendshipRequestResponse.fromPartial(object.update.request) };
+  export function fromPartial<I extends Exact<DeepPartial<BlockUserResponse>, I>>(object: I): BlockUserResponse {
+    const message = createBaseBlockUserResponse();
+    if (object.response?.$case === "ok" && object.response?.ok !== undefined && object.response?.ok !== null) {
+      message.response = { $case: "ok", ok: BlockUserResponse_Ok.fromPartial(object.response.ok) };
     }
-    if (object.update?.$case === "accept" && object.update?.accept !== undefined && object.update?.accept !== null) {
-      message.update = { $case: "accept", accept: FriendshipUpdate_AcceptResponse.fromPartial(object.update.accept) };
+    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.update?.$case === "reject" && object.update?.reject !== undefined && object.update?.reject !== null) {
-      message.update = { $case: "reject", reject: FriendshipUpdate_RejectResponse.fromPartial(object.update.reject) };
+    if (
+      object.response?.$case === "invalidRequest" &&
+      object.response?.invalidRequest !== undefined &&
+      object.response?.invalidRequest !== null
+    ) {
+      message.response = {
+        $case: "invalidRequest",
+        invalidRequest: InvalidRequest.fromPartial(object.response.invalidRequest),
+      };
     }
-    if (object.update?.$case === "delete" && object.update?.delete !== undefined && object.update?.delete !== null) {
-      message.update = { $case: "delete", delete: FriendshipUpdate_DeleteResponse.fromPartial(object.update.delete) };
+    if (
+      object.response?.$case === "profileNotFound" &&
+      object.response?.profileNotFound !== undefined &&
+      object.response?.profileNotFound !== null
+    ) {
+      message.response = {
+        $case: "profileNotFound",
+        profileNotFound: ProfileNotFound.fromPartial(object.response.profileNotFound),
+      };
     }
-    if (object.update?.$case === "cancel" && object.update?.cancel !== undefined && object.update?.cancel !== null) {
-      message.update = { $case: "cancel", cancel: FriendshipUpdate_CancelResponse.fromPartial(object.update.cancel) };
+    return message;
+  }
+}
+
+function createBaseBlockUserResponse_Ok(): BlockUserResponse_Ok {
+  return { profile: undefined };
+}
+
+export namespace BlockUserResponse_Ok {
+  export function encode(message: BlockUserResponse_Ok, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.profile !== undefined) {
+      BlockedUserProfile.encode(message.profile, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): BlockUserResponse_Ok {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseBlockUserResponse_Ok();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.profile = BlockedUserProfile.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
     }
     return message;
   }
+
+  export function fromJSON(object: any): BlockUserResponse_Ok {
+    return { profile: isSet(object.profile) ? BlockedUserProfile.fromJSON(object.profile) : undefined };
+  }
+
+  export function toJSON(message: BlockUserResponse_Ok): unknown {
+    const obj: any = {};
+    message.profile !== undefined &&
+      (obj.profile = message.profile ? BlockedUserProfile.toJSON(message.profile) : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<BlockUserResponse_Ok>, I>>(base?: I): BlockUserResponse_Ok {
+    return BlockUserResponse_Ok.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<BlockUserResponse_Ok>, I>>(object: I): BlockUserResponse_Ok {
+    const message = createBaseBlockUserResponse_Ok();
+    message.profile = (object.profile !== undefined && object.profile !== null)
+      ? BlockedUserProfile.fromPartial(object.profile)
+      : undefined;
+    return message;
+  }
 }
 
-function createBaseFriendshipUpdate_AcceptResponse(): FriendshipUpdate_AcceptResponse {
+function createBaseUnblockUserPayload(): UnblockUserPayload {
   return { user: undefined };
 }
 
-export namespace FriendshipUpdate_AcceptResponse {
-  export function encode(
-    message: FriendshipUpdate_AcceptResponse,
-    writer: _m0.Writer = _m0.Writer.create(),
-  ): _m0.Writer {
+export namespace UnblockUserPayload {
+  export function encode(message: UnblockUserPayload, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     if (message.user !== undefined) {
       User.encode(message.user, writer.uint32(10).fork()).ldelim();
     }
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): FriendshipUpdate_AcceptResponse {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): UnblockUserPayload {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseFriendshipUpdate_AcceptResponse();
+    const message = createBaseUnblockUserPayload();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -2015,50 +3542,54 @@ export namespace FriendshipUpdate_AcceptResponse {
     return message;
   }
 
-  export function fromJSON(object: any): FriendshipUpdate_AcceptResponse {
+  export function fromJSON(object: any): UnblockUserPayload {
     return { user: isSet(object.user) ? User.fromJSON(object.user) : undefined };
   }
 
-  export function toJSON(message: FriendshipUpdate_AcceptResponse): unknown {
+  export function toJSON(message: UnblockUserPayload): unknown {
     const obj: any = {};
     message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<FriendshipUpdate_AcceptResponse>, I>>(
-    base?: I,
-  ): FriendshipUpdate_AcceptResponse {
-    return FriendshipUpdate_AcceptResponse.fromPartial(base ?? {});
+  export function create<I extends Exact<DeepPartial<UnblockUserPayload>, I>>(base?: I): UnblockUserPayload {
+    return UnblockUserPayload.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<FriendshipUpdate_AcceptResponse>, I>>(
-    object: I,
-  ): FriendshipUpdate_AcceptResponse {
-    const message = createBaseFriendshipUpdate_AcceptResponse();
+  export function fromPartial<I extends Exact<DeepPartial<UnblockUserPayload>, I>>(object: I): UnblockUserPayload {
+    const message = createBaseUnblockUserPayload();
     message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
     return message;
   }
 }
 
-function createBaseFriendshipUpdate_RejectResponse(): FriendshipUpdate_RejectResponse {
-  return { user: undefined };
+function createBaseUnblockUserResponse(): UnblockUserResponse {
+  return { response: undefined };
 }
 
-export namespace FriendshipUpdate_RejectResponse {
-  export function encode(
-    message: FriendshipUpdate_RejectResponse,
-    writer: _m0.Writer = _m0.Writer.create(),
-  ): _m0.Writer {
-    if (message.user !== undefined) {
-      User.encode(message.user, writer.uint32(10).fork()).ldelim();
+export namespace UnblockUserResponse {
+  export function encode(message: UnblockUserResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    switch (message.response?.$case) {
+      case "ok":
+        UnblockUserResponse_Ok.encode(message.response.ok, writer.uint32(10).fork()).ldelim();
+        break;
+      case "internalServerError":
+        InternalServerError.encode(message.response.internalServerError, writer.uint32(18).fork()).ldelim();
+        break;
+      case "invalidRequest":
+        InvalidRequest.encode(message.response.invalidRequest, writer.uint32(26).fork()).ldelim();
+        break;
+      case "profileNotFound":
+        ProfileNotFound.encode(message.response.profileNotFound, writer.uint32(34).fork()).ldelim();
+        break;
     }
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): FriendshipUpdate_RejectResponse {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): UnblockUserResponse {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseFriendshipUpdate_RejectResponse();
+    const message = createBaseUnblockUserResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -2067,7 +3598,37 @@ export namespace FriendshipUpdate_RejectResponse {
             break;
           }
 
-          message.user = User.decode(reader, reader.uint32());
+          message.response = { $case: "ok", ok: UnblockUserResponse_Ok.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: "invalidRequest",
+            invalidRequest: InvalidRequest.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.response = {
+            $case: "profileNotFound",
+            profileNotFound: ProfileNotFound.decode(reader, reader.uint32()),
+          };
           continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
@@ -2078,50 +3639,101 @@ export namespace FriendshipUpdate_RejectResponse {
     return message;
   }
 
-  export function fromJSON(object: any): FriendshipUpdate_RejectResponse {
-    return { user: isSet(object.user) ? User.fromJSON(object.user) : undefined };
+  export function fromJSON(object: any): UnblockUserResponse {
+    return {
+      response: isSet(object.ok)
+        ? { $case: "ok", ok: UnblockUserResponse_Ok.fromJSON(object.ok) }
+        : isSet(object.internalServerError)
+        ? {
+          $case: "internalServerError",
+          internalServerError: InternalServerError.fromJSON(object.internalServerError),
+        }
+        : isSet(object.invalidRequest)
+        ? { $case: "invalidRequest", invalidRequest: InvalidRequest.fromJSON(object.invalidRequest) }
+        : isSet(object.profileNotFound)
+        ? { $case: "profileNotFound", profileNotFound: ProfileNotFound.fromJSON(object.profileNotFound) }
+        : undefined,
+    };
   }
 
-  export function toJSON(message: FriendshipUpdate_RejectResponse): unknown {
+  export function toJSON(message: UnblockUserResponse): unknown {
     const obj: any = {};
-    message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
+    message.response?.$case === "ok" &&
+      (obj.ok = message.response?.ok ? UnblockUserResponse_Ok.toJSON(message.response?.ok) : undefined);
+    message.response?.$case === "internalServerError" &&
+      (obj.internalServerError = message.response?.internalServerError
+        ? InternalServerError.toJSON(message.response?.internalServerError)
+        : undefined);
+    message.response?.$case === "invalidRequest" &&
+      (obj.invalidRequest = message.response?.invalidRequest
+        ? InvalidRequest.toJSON(message.response?.invalidRequest)
+        : undefined);
+    message.response?.$case === "profileNotFound" &&
+      (obj.profileNotFound = message.response?.profileNotFound
+        ? ProfileNotFound.toJSON(message.response?.profileNotFound)
+        : undefined);
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<FriendshipUpdate_RejectResponse>, I>>(
-    base?: I,
-  ): FriendshipUpdate_RejectResponse {
-    return FriendshipUpdate_RejectResponse.fromPartial(base ?? {});
+  export function create<I extends Exact<DeepPartial<UnblockUserResponse>, I>>(base?: I): UnblockUserResponse {
+    return UnblockUserResponse.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<FriendshipUpdate_RejectResponse>, I>>(
-    object: I,
-  ): FriendshipUpdate_RejectResponse {
-    const message = createBaseFriendshipUpdate_RejectResponse();
-    message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
+  export function fromPartial<I extends Exact<DeepPartial<UnblockUserResponse>, I>>(object: I): UnblockUserResponse {
+    const message = createBaseUnblockUserResponse();
+    if (object.response?.$case === "ok" && object.response?.ok !== undefined && object.response?.ok !== null) {
+      message.response = { $case: "ok", ok: UnblockUserResponse_Ok.fromPartial(object.response.ok) };
+    }
+    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 === "invalidRequest" &&
+      object.response?.invalidRequest !== undefined &&
+      object.response?.invalidRequest !== null
+    ) {
+      message.response = {
+        $case: "invalidRequest",
+        invalidRequest: InvalidRequest.fromPartial(object.response.invalidRequest),
+      };
+    }
+    if (
+      object.response?.$case === "profileNotFound" &&
+      object.response?.profileNotFound !== undefined &&
+      object.response?.profileNotFound !== null
+    ) {
+      message.response = {
+        $case: "profileNotFound",
+        profileNotFound: ProfileNotFound.fromPartial(object.response.profileNotFound),
+      };
+    }
     return message;
   }
 }
 
-function createBaseFriendshipUpdate_DeleteResponse(): FriendshipUpdate_DeleteResponse {
-  return { user: undefined };
+function createBaseUnblockUserResponse_Ok(): UnblockUserResponse_Ok {
+  return { profile: undefined };
 }
 
-export namespace FriendshipUpdate_DeleteResponse {
-  export function encode(
-    message: FriendshipUpdate_DeleteResponse,
-    writer: _m0.Writer = _m0.Writer.create(),
-  ): _m0.Writer {
-    if (message.user !== undefined) {
-      User.encode(message.user, writer.uint32(10).fork()).ldelim();
+export namespace UnblockUserResponse_Ok {
+  export function encode(message: UnblockUserResponse_Ok, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.profile !== undefined) {
+      BlockedUserProfile.encode(message.profile, writer.uint32(10).fork()).ldelim();
     }
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): FriendshipUpdate_DeleteResponse {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): UnblockUserResponse_Ok {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseFriendshipUpdate_DeleteResponse();
+    const message = createBaseUnblockUserResponse_Ok();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -2130,7 +3742,7 @@ export namespace FriendshipUpdate_DeleteResponse {
             break;
           }
 
-          message.user = User.decode(reader, reader.uint32());
+          message.profile = BlockedUserProfile.decode(reader, reader.uint32());
           continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
@@ -2141,50 +3753,48 @@ export namespace FriendshipUpdate_DeleteResponse {
     return message;
   }
 
-  export function fromJSON(object: any): FriendshipUpdate_DeleteResponse {
-    return { user: isSet(object.user) ? User.fromJSON(object.user) : undefined };
+  export function fromJSON(object: any): UnblockUserResponse_Ok {
+    return { profile: isSet(object.profile) ? BlockedUserProfile.fromJSON(object.profile) : undefined };
   }
 
-  export function toJSON(message: FriendshipUpdate_DeleteResponse): unknown {
+  export function toJSON(message: UnblockUserResponse_Ok): unknown {
     const obj: any = {};
-    message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
+    message.profile !== undefined &&
+      (obj.profile = message.profile ? BlockedUserProfile.toJSON(message.profile) : undefined);
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<FriendshipUpdate_DeleteResponse>, I>>(
-    base?: I,
-  ): FriendshipUpdate_DeleteResponse {
-    return FriendshipUpdate_DeleteResponse.fromPartial(base ?? {});
+  export function create<I extends Exact<DeepPartial<UnblockUserResponse_Ok>, I>>(base?: I): UnblockUserResponse_Ok {
+    return UnblockUserResponse_Ok.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<FriendshipUpdate_DeleteResponse>, I>>(
+  export function fromPartial<I extends Exact<DeepPartial<UnblockUserResponse_Ok>, I>>(
     object: I,
-  ): FriendshipUpdate_DeleteResponse {
-    const message = createBaseFriendshipUpdate_DeleteResponse();
-    message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
+  ): UnblockUserResponse_Ok {
+    const message = createBaseUnblockUserResponse_Ok();
+    message.profile = (object.profile !== undefined && object.profile !== null)
+      ? BlockedUserProfile.fromPartial(object.profile)
+      : undefined;
     return message;
   }
 }
 
-function createBaseFriendshipUpdate_CancelResponse(): FriendshipUpdate_CancelResponse {
-  return { user: undefined };
+function createBaseGetBlockedUsersPayload(): GetBlockedUsersPayload {
+  return { pagination: undefined };
 }
 
-export namespace FriendshipUpdate_CancelResponse {
-  export function encode(
-    message: FriendshipUpdate_CancelResponse,
-    writer: _m0.Writer = _m0.Writer.create(),
-  ): _m0.Writer {
-    if (message.user !== undefined) {
-      User.encode(message.user, writer.uint32(10).fork()).ldelim();
+export namespace GetBlockedUsersPayload {
+  export function encode(message: GetBlockedUsersPayload, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.pagination !== undefined) {
+      Pagination.encode(message.pagination, writer.uint32(10).fork()).ldelim();
     }
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): FriendshipUpdate_CancelResponse {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): GetBlockedUsersPayload {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseFriendshipUpdate_CancelResponse();
+    const message = createBaseGetBlockedUsersPayload();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -2193,7 +3803,7 @@ export namespace FriendshipUpdate_CancelResponse {
             break;
           }
 
-          message.user = User.decode(reader, reader.uint32());
+          message.pagination = Pagination.decode(reader, reader.uint32());
           continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
@@ -2204,47 +3814,51 @@ export namespace FriendshipUpdate_CancelResponse {
     return message;
   }
 
-  export function fromJSON(object: any): FriendshipUpdate_CancelResponse {
-    return { user: isSet(object.user) ? User.fromJSON(object.user) : undefined };
+  export function fromJSON(object: any): GetBlockedUsersPayload {
+    return { pagination: isSet(object.pagination) ? Pagination.fromJSON(object.pagination) : undefined };
   }
 
-  export function toJSON(message: FriendshipUpdate_CancelResponse): unknown {
+  export function toJSON(message: GetBlockedUsersPayload): unknown {
     const obj: any = {};
-    message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
+    message.pagination !== undefined &&
+      (obj.pagination = message.pagination ? Pagination.toJSON(message.pagination) : undefined);
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<FriendshipUpdate_CancelResponse>, I>>(
-    base?: I,
-  ): FriendshipUpdate_CancelResponse {
-    return FriendshipUpdate_CancelResponse.fromPartial(base ?? {});
+  export function create<I extends Exact<DeepPartial<GetBlockedUsersPayload>, I>>(base?: I): GetBlockedUsersPayload {
+    return GetBlockedUsersPayload.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<FriendshipUpdate_CancelResponse>, I>>(
+  export function fromPartial<I extends Exact<DeepPartial<GetBlockedUsersPayload>, I>>(
     object: I,
-  ): FriendshipUpdate_CancelResponse {
-    const message = createBaseFriendshipUpdate_CancelResponse();
-    message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
+  ): GetBlockedUsersPayload {
+    const message = createBaseGetBlockedUsersPayload();
+    message.pagination = (object.pagination !== undefined && object.pagination !== null)
+      ? Pagination.fromPartial(object.pagination)
+      : undefined;
     return message;
   }
 }
 
-function createBaseGetFriendshipStatusPayload(): GetFriendshipStatusPayload {
-  return { user: undefined };
+function createBaseGetBlockedUsersResponse(): GetBlockedUsersResponse {
+  return { profiles: [], paginationData: undefined };
 }
 
-export namespace GetFriendshipStatusPayload {
-  export function encode(message: GetFriendshipStatusPayload, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.user !== undefined) {
-      User.encode(message.user, writer.uint32(10).fork()).ldelim();
+export namespace GetBlockedUsersResponse {
+  export function encode(message: GetBlockedUsersResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.profiles) {
+      BlockedUserProfile.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.paginationData !== undefined) {
+      PaginatedResponse.encode(message.paginationData, writer.uint32(18).fork()).ldelim();
     }
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): GetFriendshipStatusPayload {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): GetBlockedUsersResponse {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseGetFriendshipStatusPayload();
+    const message = createBaseGetBlockedUsersResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -2253,7 +3867,14 @@ export namespace GetFriendshipStatusPayload {
             break;
           }
 
-          message.user = User.decode(reader, reader.uint32());
+          message.profiles.push(BlockedUserProfile.decode(reader, reader.uint32()));
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.paginationData = PaginatedResponse.decode(reader, reader.uint32());
           continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
@@ -2264,52 +3885,60 @@ export namespace GetFriendshipStatusPayload {
     return message;
   }
 
-  export function fromJSON(object: any): GetFriendshipStatusPayload {
-    return { user: isSet(object.user) ? User.fromJSON(object.user) : undefined };
+  export function fromJSON(object: any): GetBlockedUsersResponse {
+    return {
+      profiles: Array.isArray(object?.profiles) ? object.profiles.map((e: any) => BlockedUserProfile.fromJSON(e)) : [],
+      paginationData: isSet(object.paginationData) ? PaginatedResponse.fromJSON(object.paginationData) : undefined,
+    };
   }
 
-  export function toJSON(message: GetFriendshipStatusPayload): unknown {
+  export function toJSON(message: GetBlockedUsersResponse): unknown {
     const obj: any = {};
-    message.user !== undefined && (obj.user = message.user ? User.toJSON(message.user) : undefined);
+    if (message.profiles) {
+      obj.profiles = message.profiles.map((e) => e ? BlockedUserProfile.toJSON(e) : undefined);
+    } else {
+      obj.profiles = [];
+    }
+    message.paginationData !== undefined &&
+      (obj.paginationData = message.paginationData ? PaginatedResponse.toJSON(message.paginationData) : undefined);
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<GetFriendshipStatusPayload>, I>>(
-    base?: I,
-  ): GetFriendshipStatusPayload {
-    return GetFriendshipStatusPayload.fromPartial(base ?? {});
+  export function create<I extends Exact<DeepPartial<GetBlockedUsersResponse>, I>>(base?: I): GetBlockedUsersResponse {
+    return GetBlockedUsersResponse.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<GetFriendshipStatusPayload>, I>>(
+  export function fromPartial<I extends Exact<DeepPartial<GetBlockedUsersResponse>, I>>(
     object: I,
-  ): GetFriendshipStatusPayload {
-    const message = createBaseGetFriendshipStatusPayload();
-    message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
+  ): GetBlockedUsersResponse {
+    const message = createBaseGetBlockedUsersResponse();
+    message.profiles = object.profiles?.map((e) => BlockedUserProfile.fromPartial(e)) || [];
+    message.paginationData = (object.paginationData !== undefined && object.paginationData !== null)
+      ? PaginatedResponse.fromPartial(object.paginationData)
+      : undefined;
     return message;
   }
 }
 
-function createBaseGetFriendshipStatusResponse(): GetFriendshipStatusResponse {
-  return { response: undefined };
+function createBaseGetBlockingStatusResponse(): GetBlockingStatusResponse {
+  return { blockedUsers: [], blockedByUsers: [] };
 }
 
-export namespace GetFriendshipStatusResponse {
-  export function encode(message: GetFriendshipStatusResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    switch (message.response?.$case) {
-      case "accepted":
-        GetFriendshipStatusResponse_Ok.encode(message.response.accepted, writer.uint32(10).fork()).ldelim();
-        break;
-      case "internalServerError":
-        InternalServerError.encode(message.response.internalServerError, writer.uint32(18).fork()).ldelim();
-        break;
+export namespace GetBlockingStatusResponse {
+  export function encode(message: GetBlockingStatusResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.blockedUsers) {
+      writer.uint32(10).string(v!);
+    }
+    for (const v of message.blockedByUsers) {
+      writer.uint32(18).string(v!);
     }
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): GetFriendshipStatusResponse {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): GetBlockingStatusResponse {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseGetFriendshipStatusResponse();
+    const message = createBaseGetBlockingStatusResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -2318,20 +3947,14 @@ export namespace GetFriendshipStatusResponse {
             break;
           }
 
-          message.response = {
-            $case: "accepted",
-            accepted: GetFriendshipStatusResponse_Ok.decode(reader, reader.uint32()),
-          };
+          message.blockedUsers.push(reader.string());
           continue;
         case 2:
           if (tag !== 18) {
             break;
           }
 
-          message.response = {
-            $case: "internalServerError",
-            internalServerError: InternalServerError.decode(reader, reader.uint32()),
-          };
+          message.blockedByUsers.push(reader.string());
           continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
@@ -2342,104 +3965,79 @@ export namespace GetFriendshipStatusResponse {
     return message;
   }
 
-  export function fromJSON(object: any): GetFriendshipStatusResponse {
+  export function fromJSON(object: any): GetBlockingStatusResponse {
     return {
-      response: isSet(object.accepted)
-        ? { $case: "accepted", accepted: GetFriendshipStatusResponse_Ok.fromJSON(object.accepted) }
-        : isSet(object.internalServerError)
-        ? {
-          $case: "internalServerError",
-          internalServerError: InternalServerError.fromJSON(object.internalServerError),
-        }
-        : undefined,
+      blockedUsers: Array.isArray(object?.blockedUsers) ? object.blockedUsers.map((e: any) => String(e)) : [],
+      blockedByUsers: Array.isArray(object?.blockedByUsers) ? object.blockedByUsers.map((e: any) => String(e)) : [],
     };
   }
 
-  export function toJSON(message: GetFriendshipStatusResponse): unknown {
+  export function toJSON(message: GetBlockingStatusResponse): unknown {
     const obj: any = {};
-    message.response?.$case === "accepted" &&
-      (obj.accepted = message.response?.accepted
-        ? GetFriendshipStatusResponse_Ok.toJSON(message.response?.accepted)
-        : undefined);
-    message.response?.$case === "internalServerError" &&
-      (obj.internalServerError = message.response?.internalServerError
-        ? InternalServerError.toJSON(message.response?.internalServerError)
-        : undefined);
+    if (message.blockedUsers) {
+      obj.blockedUsers = message.blockedUsers.map((e) => e);
+    } else {
+      obj.blockedUsers = [];
+    }
+    if (message.blockedByUsers) {
+      obj.blockedByUsers = message.blockedByUsers.map((e) => e);
+    } else {
+      obj.blockedByUsers = [];
+    }
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<GetFriendshipStatusResponse>, I>>(
+  export function create<I extends Exact<DeepPartial<GetBlockingStatusResponse>, I>>(
     base?: I,
-  ): GetFriendshipStatusResponse {
-    return GetFriendshipStatusResponse.fromPartial(base ?? {});
+  ): GetBlockingStatusResponse {
+    return GetBlockingStatusResponse.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<GetFriendshipStatusResponse>, I>>(
+  export function fromPartial<I extends Exact<DeepPartial<GetBlockingStatusResponse>, I>>(
     object: I,
-  ): GetFriendshipStatusResponse {
-    const message = createBaseGetFriendshipStatusResponse();
-    if (
-      object.response?.$case === "accepted" &&
-      object.response?.accepted !== undefined &&
-      object.response?.accepted !== null
-    ) {
-      message.response = {
-        $case: "accepted",
-        accepted: GetFriendshipStatusResponse_Ok.fromPartial(object.response.accepted),
-      };
-    }
-    if (
-      object.response?.$case === "internalServerError" &&
-      object.response?.internalServerError !== undefined &&
-      object.response?.internalServerError !== null
-    ) {
-      message.response = {
-        $case: "internalServerError",
-        internalServerError: InternalServerError.fromPartial(object.response.internalServerError),
-      };
-    }
+  ): GetBlockingStatusResponse {
+    const message = createBaseGetBlockingStatusResponse();
+    message.blockedUsers = object.blockedUsers?.map((e) => e) || [];
+    message.blockedByUsers = object.blockedByUsers?.map((e) => e) || [];
     return message;
   }
 }
 
-function createBaseGetFriendshipStatusResponse_Ok(): GetFriendshipStatusResponse_Ok {
-  return { status: 0, message: undefined };
+function createBaseBlockUpdate(): BlockUpdate {
+  return { address: "", isBlocked: false };
 }
 
-export namespace GetFriendshipStatusResponse_Ok {
-  export function encode(
-    message: GetFriendshipStatusResponse_Ok,
-    writer: _m0.Writer = _m0.Writer.create(),
-  ): _m0.Writer {
-    if (message.status !== 0) {
-      writer.uint32(8).int32(message.status);
+export namespace BlockUpdate {
+  export function encode(message: BlockUpdate, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
     }
-    if (message.message !== undefined) {
-      writer.uint32(18).string(message.message);
+    if (message.isBlocked === true) {
+      writer.uint32(16).bool(message.isBlocked);
     }
     return writer;
   }
 
-  export function decode(input: _m0.Reader | Uint8Array, length?: number): GetFriendshipStatusResponse_Ok {
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): BlockUpdate {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseGetFriendshipStatusResponse_Ok();
+    const message = createBaseBlockUpdate();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          if (tag !== 8) {
+          if (tag !== 10) {
             break;
           }
 
-          message.status = reader.int32() as any;
+          message.address = reader.string();
           continue;
         case 2:
-          if (tag !== 18) {
+          if (tag !== 16) {
             break;
           }
 
-          message.message = reader.string();
+          message.isBlocked = reader.bool();
           continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
@@ -2450,32 +4048,28 @@ export namespace GetFriendshipStatusResponse_Ok {
     return message;
   }
 
-  export function fromJSON(object: any): GetFriendshipStatusResponse_Ok {
+  export function fromJSON(object: any): BlockUpdate {
     return {
-      status: isSet(object.status) ? friendshipStatusFromJSON(object.status) : 0,
-      message: isSet(object.message) ? String(object.message) : undefined,
+      address: isSet(object.address) ? String(object.address) : "",
+      isBlocked: isSet(object.isBlocked) ? Boolean(object.isBlocked) : false,
     };
   }
 
-  export function toJSON(message: GetFriendshipStatusResponse_Ok): unknown {
+  export function toJSON(message: BlockUpdate): unknown {
     const obj: any = {};
-    message.status !== undefined && (obj.status = friendshipStatusToJSON(message.status));
-    message.message !== undefined && (obj.message = message.message);
+    message.address !== undefined && (obj.address = message.address);
+    message.isBlocked !== undefined && (obj.isBlocked = message.isBlocked);
     return obj;
   }
 
-  export function create<I extends Exact<DeepPartial<GetFriendshipStatusResponse_Ok>, I>>(
-    base?: I,
-  ): GetFriendshipStatusResponse_Ok {
-    return GetFriendshipStatusResponse_Ok.fromPartial(base ?? {});
+  export function create<I extends Exact<DeepPartial<BlockUpdate>, I>>(base?: I): BlockUpdate {
+    return BlockUpdate.fromPartial(base ?? {});
   }
 
-  export function fromPartial<I extends Exact<DeepPartial<GetFriendshipStatusResponse_Ok>, I>>(
-    object: I,
-  ): GetFriendshipStatusResponse_Ok {
-    const message = createBaseGetFriendshipStatusResponse_Ok();
-    message.status = object.status ?? 0;
-    message.message = object.message ?? undefined;
+  export function fromPartial<I extends Exact<DeepPartial<BlockUpdate>, I>>(object: I): BlockUpdate {
+    const message = createBaseBlockUpdate();
+    message.address = object.address ?? "";
+    message.isBlocked = object.isBlocked ?? false;
     return message;
   }
 }
@@ -2490,7 +4084,7 @@ export const SocialServiceDefinition = {
       name: "GetFriends",
       requestType: GetFriendsPayload,
       requestStream: false,
-      responseType: PaginatedUsersResponse,
+      responseType: PaginatedFriendsProfilesResponse,
       responseStream: false,
       options: {},
     },
@@ -2499,7 +4093,7 @@ export const SocialServiceDefinition = {
       name: "GetMutualFriends",
       requestType: GetMutualFriendsPayload,
       requestStream: false,
-      responseType: PaginatedUsersResponse,
+      responseType: PaginatedFriendsProfilesResponse,
       responseStream: false,
       options: {},
     },
@@ -2539,6 +4133,7 @@ export const SocialServiceDefinition = {
       responseStream: true,
       options: {},
     },
+    /** Get the friendship status between the authenticated user and the one in the parameter */
     getFriendshipStatus: {
       name: "GetFriendshipStatus",
       requestType: GetFriendshipStatusPayload,
@@ -2547,6 +4142,55 @@ export const SocialServiceDefinition = {
       responseStream: false,
       options: {},
     },
+    /** Subscribe to connectivity updates of friends: ONLINE, OFFLINE, AWAY */
+    subscribeToFriendConnectivityUpdates: {
+      name: "SubscribeToFriendConnectivityUpdates",
+      requestType: Empty,
+      requestStream: false,
+      responseType: FriendConnectivityUpdate,
+      responseStream: true,
+      options: {},
+    },
+    blockUser: {
+      name: "BlockUser",
+      requestType: BlockUserPayload,
+      requestStream: false,
+      responseType: BlockUserResponse,
+      responseStream: false,
+      options: {},
+    },
+    unblockUser: {
+      name: "UnblockUser",
+      requestType: UnblockUserPayload,
+      requestStream: false,
+      responseType: UnblockUserResponse,
+      responseStream: false,
+      options: {},
+    },
+    getBlockedUsers: {
+      name: "GetBlockedUsers",
+      requestType: GetBlockedUsersPayload,
+      requestStream: false,
+      responseType: GetBlockedUsersResponse,
+      responseStream: false,
+      options: {},
+    },
+    getBlockingStatus: {
+      name: "GetBlockingStatus",
+      requestType: Empty,
+      requestStream: false,
+      responseType: GetBlockingStatusResponse,
+      responseStream: false,
+      options: {},
+    },
+    subscribeToBlockUpdates: {
+      name: "SubscribeToBlockUpdates",
+      requestType: Empty,
+      requestStream: false,
+      responseType: BlockUpdate,
+      responseStream: true,
+      options: {},
+    },
   },
 } as const;