// @ts-nocheck
/* eslint-disable */
import * as Long from "long";
import { grpc } from "@improbable-eng/grpc-web";
import * as _m0 from "protobufjs/minimal";
import { AuthUser } from "./auth";
import { FileExtendsPermission } from "./files";
import { ListOption } from "./utils";
import { Empty } from "./google/protobuf/empty";
import { BrowserHeaders } from "browser-headers";

export const protobufPackage = "api.v1";

export interface RoomInfo {
  id: string;
  name: string;
  avatar: string;
  org_id: string;
  created_at: string;
  creator_id: string;
  updated_at: string;
  updated_by?: string | undefined;
  creator: AuthUser;
  allow_user_ids: string[];
  records: ChatRecord[];
  last_record: ChatRecord;
}

export interface ChatRecord {
  id: string;
  room_id: string;
  from_user_id: string;
  message: MsgInfo[];
  to_user_ids: string[];
  created_at: number;
  from_user_name: string;
  from_user_avatar: string;
}

export interface MsgInfo {
  type: string;
  sub_type: string;
  text: string;
  user_id?: string | undefined;
  source_url: string;
  card_id: string;
  file_id: string;
  file: FileExtendsPermission;
}

export interface RedisRoomUserMap {
  name: string;
  avatar: string;
}

export interface GetOrgChatRoomsRequest {
  username: string;
}

export interface GetOrgChatRoomsResponse {
  rooms: RoomInfo[];
}

export interface GetRoomInfoRequest {
  username: string;
  id: string;
}

export interface GetRoomInfoResponse {
  room: RoomInfo;
  online_user_ids: string[];
  records: ChatRecord[];
  count: number;
}

export interface GetRoomRecordsRequest {
  username: string;
  room_id: string;
  record_id?: string | undefined;
  is_before: boolean;
  list_option: ListOption;
}

export interface GetRoomRecordsResponse {
  records: ChatRecord[];
  count: number;
}

export interface CreateChatRoomRequest {
  name: string;
  allow_user_ids: string[];
  username: string;
}

export interface UpdateChatRoomRequest {
  room_id: string;
  name?: string | undefined;
  allow_user_ids: string[];
  username: string;
}

export interface DeleteChatRoomRequest {
  id: string;
  username: string;
}

export interface PushMessageRequest {
  message: MsgInfo[];
  to_user_ids: string[];
  room_id: string;
  username: string;
}

function createBaseRoomInfo(): RoomInfo {
  return {
    id: "",
    name: "",
    avatar: "",
    org_id: "",
    created_at: "",
    creator_id: "",
    updated_at: "",
    updated_by: undefined,
    creator: undefined,
    allow_user_ids: [],
    records: [],
    last_record: undefined,
  };
}

export const RoomInfo = {
  encode(
    message: RoomInfo,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.id !== "") {
      writer.uint32(10).string(message.id);
    }
    if (message.name !== "") {
      writer.uint32(18).string(message.name);
    }
    if (message.avatar !== "") {
      writer.uint32(26).string(message.avatar);
    }
    if (message.org_id !== "") {
      writer.uint32(34).string(message.org_id);
    }
    if (message.created_at !== "") {
      writer.uint32(42).string(message.created_at);
    }
    if (message.creator_id !== "") {
      writer.uint32(50).string(message.creator_id);
    }
    if (message.updated_at !== "") {
      writer.uint32(58).string(message.updated_at);
    }
    if (message.updated_by !== undefined) {
      writer.uint32(66).string(message.updated_by);
    }
    if (message.creator !== undefined) {
      AuthUser.encode(message.creator, writer.uint32(74).fork()).ldelim();
    }
    for (const v of message.allow_user_ids) {
      writer.uint32(82).string(v!);
    }
    for (const v of message.records) {
      ChatRecord.encode(v!, writer.uint32(90).fork()).ldelim();
    }
    if (message.last_record !== undefined) {
      ChatRecord.encode(message.last_record, writer.uint32(98).fork()).ldelim();
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): RoomInfo {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseRoomInfo();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.id = reader.string();
          break;
        case 2:
          message.name = reader.string();
          break;
        case 3:
          message.avatar = reader.string();
          break;
        case 4:
          message.org_id = reader.string();
          break;
        case 5:
          message.created_at = reader.string();
          break;
        case 6:
          message.creator_id = reader.string();
          break;
        case 7:
          message.updated_at = reader.string();
          break;
        case 8:
          message.updated_by = reader.string();
          break;
        case 9:
          message.creator = AuthUser.decode(reader, reader.uint32());
          break;
        case 10:
          message.allow_user_ids.push(reader.string());
          break;
        case 11:
          message.records.push(ChatRecord.decode(reader, reader.uint32()));
          break;
        case 12:
          message.last_record = ChatRecord.decode(reader, reader.uint32());
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): RoomInfo {
    return {
      id: isSet(object.id) ? String(object.id) : "",
      name: isSet(object.name) ? String(object.name) : "",
      avatar: isSet(object.avatar) ? String(object.avatar) : "",
      org_id: isSet(object.org_id) ? String(object.org_id) : "",
      created_at: isSet(object.created_at) ? String(object.created_at) : "",
      creator_id: isSet(object.creator_id) ? String(object.creator_id) : "",
      updated_at: isSet(object.updated_at) ? String(object.updated_at) : "",
      updated_by: isSet(object.updated_by)
        ? String(object.updated_by)
        : undefined,
      creator: isSet(object.creator)
        ? AuthUser.fromJSON(object.creator)
        : undefined,
      allow_user_ids: Array.isArray(object?.allow_user_ids)
        ? object.allow_user_ids.map((e: any) => String(e))
        : [],
      records: Array.isArray(object?.records)
        ? object.records.map((e: any) => ChatRecord.fromJSON(e))
        : [],
      last_record: isSet(object.last_record)
        ? ChatRecord.fromJSON(object.last_record)
        : undefined,
    };
  },

  toJSON(message: RoomInfo): unknown {
    const obj: any = {};
    message.id !== undefined && (obj.id = message.id);
    message.name !== undefined && (obj.name = message.name);
    message.avatar !== undefined && (obj.avatar = message.avatar);
    message.org_id !== undefined && (obj.org_id = message.org_id);
    message.created_at !== undefined && (obj.created_at = message.created_at);
    message.creator_id !== undefined && (obj.creator_id = message.creator_id);
    message.updated_at !== undefined && (obj.updated_at = message.updated_at);
    message.updated_by !== undefined && (obj.updated_by = message.updated_by);
    message.creator !== undefined &&
      (obj.creator = message.creator
        ? AuthUser.toJSON(message.creator)
        : undefined);
    if (message.allow_user_ids) {
      obj.allow_user_ids = message.allow_user_ids.map((e) => e);
    } else {
      obj.allow_user_ids = [];
    }
    if (message.records) {
      obj.records = message.records.map((e) =>
        e ? ChatRecord.toJSON(e) : undefined
      );
    } else {
      obj.records = [];
    }
    message.last_record !== undefined &&
      (obj.last_record = message.last_record
        ? ChatRecord.toJSON(message.last_record)
        : undefined);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<RoomInfo>, I>>(object: I): RoomInfo {
    const message = createBaseRoomInfo();
    message.id = object.id ?? "";
    message.name = object.name ?? "";
    message.avatar = object.avatar ?? "";
    message.org_id = object.org_id ?? "";
    message.created_at = object.created_at ?? "";
    message.creator_id = object.creator_id ?? "";
    message.updated_at = object.updated_at ?? "";
    message.updated_by = object.updated_by ?? undefined;
    message.creator =
      object.creator !== undefined && object.creator !== null
        ? AuthUser.fromPartial(object.creator)
        : undefined;
    message.allow_user_ids = object.allow_user_ids?.map((e) => e) || [];
    message.records =
      object.records?.map((e) => ChatRecord.fromPartial(e)) || [];
    message.last_record =
      object.last_record !== undefined && object.last_record !== null
        ? ChatRecord.fromPartial(object.last_record)
        : undefined;
    return message;
  },
};

function createBaseChatRecord(): ChatRecord {
  return {
    id: "",
    room_id: "",
    from_user_id: "",
    message: [],
    to_user_ids: [],
    created_at: 0,
    from_user_name: "",
    from_user_avatar: "",
  };
}

export const ChatRecord = {
  encode(
    message: ChatRecord,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.id !== "") {
      writer.uint32(10).string(message.id);
    }
    if (message.room_id !== "") {
      writer.uint32(18).string(message.room_id);
    }
    if (message.from_user_id !== "") {
      writer.uint32(26).string(message.from_user_id);
    }
    for (const v of message.message) {
      MsgInfo.encode(v!, writer.uint32(34).fork()).ldelim();
    }
    for (const v of message.to_user_ids) {
      writer.uint32(42).string(v!);
    }
    if (message.created_at !== 0) {
      writer.uint32(48).int64(message.created_at);
    }
    if (message.from_user_name !== "") {
      writer.uint32(58).string(message.from_user_name);
    }
    if (message.from_user_avatar !== "") {
      writer.uint32(66).string(message.from_user_avatar);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): ChatRecord {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseChatRecord();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.id = reader.string();
          break;
        case 2:
          message.room_id = reader.string();
          break;
        case 3:
          message.from_user_id = reader.string();
          break;
        case 4:
          message.message.push(MsgInfo.decode(reader, reader.uint32()));
          break;
        case 5:
          message.to_user_ids.push(reader.string());
          break;
        case 6:
          message.created_at = longToNumber(reader.int64() as Long);
          break;
        case 7:
          message.from_user_name = reader.string();
          break;
        case 8:
          message.from_user_avatar = reader.string();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): ChatRecord {
    return {
      id: isSet(object.id) ? String(object.id) : "",
      room_id: isSet(object.room_id) ? String(object.room_id) : "",
      from_user_id: isSet(object.from_user_id)
        ? String(object.from_user_id)
        : "",
      message: Array.isArray(object?.message)
        ? object.message.map((e: any) => MsgInfo.fromJSON(e))
        : [],
      to_user_ids: Array.isArray(object?.to_user_ids)
        ? object.to_user_ids.map((e: any) => String(e))
        : [],
      created_at: isSet(object.created_at) ? Number(object.created_at) : 0,
      from_user_name: isSet(object.from_user_name)
        ? String(object.from_user_name)
        : "",
      from_user_avatar: isSet(object.from_user_avatar)
        ? String(object.from_user_avatar)
        : "",
    };
  },

  toJSON(message: ChatRecord): unknown {
    const obj: any = {};
    message.id !== undefined && (obj.id = message.id);
    message.room_id !== undefined && (obj.room_id = message.room_id);
    message.from_user_id !== undefined &&
      (obj.from_user_id = message.from_user_id);
    if (message.message) {
      obj.message = message.message.map((e) =>
        e ? MsgInfo.toJSON(e) : undefined
      );
    } else {
      obj.message = [];
    }
    if (message.to_user_ids) {
      obj.to_user_ids = message.to_user_ids.map((e) => e);
    } else {
      obj.to_user_ids = [];
    }
    message.created_at !== undefined &&
      (obj.created_at = Math.round(message.created_at));
    message.from_user_name !== undefined &&
      (obj.from_user_name = message.from_user_name);
    message.from_user_avatar !== undefined &&
      (obj.from_user_avatar = message.from_user_avatar);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<ChatRecord>, I>>(
    object: I
  ): ChatRecord {
    const message = createBaseChatRecord();
    message.id = object.id ?? "";
    message.room_id = object.room_id ?? "";
    message.from_user_id = object.from_user_id ?? "";
    message.message = object.message?.map((e) => MsgInfo.fromPartial(e)) || [];
    message.to_user_ids = object.to_user_ids?.map((e) => e) || [];
    message.created_at = object.created_at ?? 0;
    message.from_user_name = object.from_user_name ?? "";
    message.from_user_avatar = object.from_user_avatar ?? "";
    return message;
  },
};

function createBaseMsgInfo(): MsgInfo {
  return {
    type: "",
    sub_type: "",
    text: "",
    user_id: undefined,
    source_url: "",
    card_id: "",
    file_id: "",
    file: undefined,
  };
}

export const MsgInfo = {
  encode(
    message: MsgInfo,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.type !== "") {
      writer.uint32(10).string(message.type);
    }
    if (message.sub_type !== "") {
      writer.uint32(18).string(message.sub_type);
    }
    if (message.text !== "") {
      writer.uint32(26).string(message.text);
    }
    if (message.user_id !== undefined) {
      writer.uint32(34).string(message.user_id);
    }
    if (message.source_url !== "") {
      writer.uint32(42).string(message.source_url);
    }
    if (message.card_id !== "") {
      writer.uint32(50).string(message.card_id);
    }
    if (message.file_id !== "") {
      writer.uint32(58).string(message.file_id);
    }
    if (message.file !== undefined) {
      FileExtendsPermission.encode(
        message.file,
        writer.uint32(66).fork()
      ).ldelim();
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): MsgInfo {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseMsgInfo();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.type = reader.string();
          break;
        case 2:
          message.sub_type = reader.string();
          break;
        case 3:
          message.text = reader.string();
          break;
        case 4:
          message.user_id = reader.string();
          break;
        case 5:
          message.source_url = reader.string();
          break;
        case 6:
          message.card_id = reader.string();
          break;
        case 7:
          message.file_id = reader.string();
          break;
        case 8:
          message.file = FileExtendsPermission.decode(reader, reader.uint32());
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): MsgInfo {
    return {
      type: isSet(object.type) ? String(object.type) : "",
      sub_type: isSet(object.sub_type) ? String(object.sub_type) : "",
      text: isSet(object.text) ? String(object.text) : "",
      user_id: isSet(object.user_id) ? String(object.user_id) : undefined,
      source_url: isSet(object.source_url) ? String(object.source_url) : "",
      card_id: isSet(object.card_id) ? String(object.card_id) : "",
      file_id: isSet(object.file_id) ? String(object.file_id) : "",
      file: isSet(object.file)
        ? FileExtendsPermission.fromJSON(object.file)
        : undefined,
    };
  },

  toJSON(message: MsgInfo): unknown {
    const obj: any = {};
    message.type !== undefined && (obj.type = message.type);
    message.sub_type !== undefined && (obj.sub_type = message.sub_type);
    message.text !== undefined && (obj.text = message.text);
    message.user_id !== undefined && (obj.user_id = message.user_id);
    message.source_url !== undefined && (obj.source_url = message.source_url);
    message.card_id !== undefined && (obj.card_id = message.card_id);
    message.file_id !== undefined && (obj.file_id = message.file_id);
    message.file !== undefined &&
      (obj.file = message.file
        ? FileExtendsPermission.toJSON(message.file)
        : undefined);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<MsgInfo>, I>>(object: I): MsgInfo {
    const message = createBaseMsgInfo();
    message.type = object.type ?? "";
    message.sub_type = object.sub_type ?? "";
    message.text = object.text ?? "";
    message.user_id = object.user_id ?? undefined;
    message.source_url = object.source_url ?? "";
    message.card_id = object.card_id ?? "";
    message.file_id = object.file_id ?? "";
    message.file =
      object.file !== undefined && object.file !== null
        ? FileExtendsPermission.fromPartial(object.file)
        : undefined;
    return message;
  },
};

function createBaseRedisRoomUserMap(): RedisRoomUserMap {
  return { name: "", avatar: "" };
}

export const RedisRoomUserMap = {
  encode(
    message: RedisRoomUserMap,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.name !== "") {
      writer.uint32(10).string(message.name);
    }
    if (message.avatar !== "") {
      writer.uint32(18).string(message.avatar);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): RedisRoomUserMap {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseRedisRoomUserMap();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.name = reader.string();
          break;
        case 2:
          message.avatar = reader.string();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): RedisRoomUserMap {
    return {
      name: isSet(object.name) ? String(object.name) : "",
      avatar: isSet(object.avatar) ? String(object.avatar) : "",
    };
  },

  toJSON(message: RedisRoomUserMap): unknown {
    const obj: any = {};
    message.name !== undefined && (obj.name = message.name);
    message.avatar !== undefined && (obj.avatar = message.avatar);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<RedisRoomUserMap>, I>>(
    object: I
  ): RedisRoomUserMap {
    const message = createBaseRedisRoomUserMap();
    message.name = object.name ?? "";
    message.avatar = object.avatar ?? "";
    return message;
  },
};

function createBaseGetOrgChatRoomsRequest(): GetOrgChatRoomsRequest {
  return { username: "" };
}

export const GetOrgChatRoomsRequest = {
  encode(
    message: GetOrgChatRoomsRequest,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.username !== "") {
      writer.uint32(10).string(message.username);
    }
    return writer;
  },

  decode(
    input: _m0.Reader | Uint8Array,
    length?: number
  ): GetOrgChatRoomsRequest {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseGetOrgChatRoomsRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.username = reader.string();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): GetOrgChatRoomsRequest {
    return {
      username: isSet(object.username) ? String(object.username) : "",
    };
  },

  toJSON(message: GetOrgChatRoomsRequest): unknown {
    const obj: any = {};
    message.username !== undefined && (obj.username = message.username);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<GetOrgChatRoomsRequest>, I>>(
    object: I
  ): GetOrgChatRoomsRequest {
    const message = createBaseGetOrgChatRoomsRequest();
    message.username = object.username ?? "";
    return message;
  },
};

function createBaseGetOrgChatRoomsResponse(): GetOrgChatRoomsResponse {
  return { rooms: [] };
}

export const GetOrgChatRoomsResponse = {
  encode(
    message: GetOrgChatRoomsResponse,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    for (const v of message.rooms) {
      RoomInfo.encode(v!, writer.uint32(10).fork()).ldelim();
    }
    return writer;
  },

  decode(
    input: _m0.Reader | Uint8Array,
    length?: number
  ): GetOrgChatRoomsResponse {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseGetOrgChatRoomsResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.rooms.push(RoomInfo.decode(reader, reader.uint32()));
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): GetOrgChatRoomsResponse {
    return {
      rooms: Array.isArray(object?.rooms)
        ? object.rooms.map((e: any) => RoomInfo.fromJSON(e))
        : [],
    };
  },

  toJSON(message: GetOrgChatRoomsResponse): unknown {
    const obj: any = {};
    if (message.rooms) {
      obj.rooms = message.rooms.map((e) =>
        e ? RoomInfo.toJSON(e) : undefined
      );
    } else {
      obj.rooms = [];
    }
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<GetOrgChatRoomsResponse>, I>>(
    object: I
  ): GetOrgChatRoomsResponse {
    const message = createBaseGetOrgChatRoomsResponse();
    message.rooms = object.rooms?.map((e) => RoomInfo.fromPartial(e)) || [];
    return message;
  },
};

function createBaseGetRoomInfoRequest(): GetRoomInfoRequest {
  return { username: "", id: "" };
}

export const GetRoomInfoRequest = {
  encode(
    message: GetRoomInfoRequest,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.username !== "") {
      writer.uint32(10).string(message.username);
    }
    if (message.id !== "") {
      writer.uint32(18).string(message.id);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): GetRoomInfoRequest {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseGetRoomInfoRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.username = reader.string();
          break;
        case 2:
          message.id = reader.string();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): GetRoomInfoRequest {
    return {
      username: isSet(object.username) ? String(object.username) : "",
      id: isSet(object.id) ? String(object.id) : "",
    };
  },

  toJSON(message: GetRoomInfoRequest): unknown {
    const obj: any = {};
    message.username !== undefined && (obj.username = message.username);
    message.id !== undefined && (obj.id = message.id);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<GetRoomInfoRequest>, I>>(
    object: I
  ): GetRoomInfoRequest {
    const message = createBaseGetRoomInfoRequest();
    message.username = object.username ?? "";
    message.id = object.id ?? "";
    return message;
  },
};

function createBaseGetRoomInfoResponse(): GetRoomInfoResponse {
  return { room: undefined, online_user_ids: [], records: [], count: 0 };
}

export const GetRoomInfoResponse = {
  encode(
    message: GetRoomInfoResponse,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.room !== undefined) {
      RoomInfo.encode(message.room, writer.uint32(10).fork()).ldelim();
    }
    for (const v of message.online_user_ids) {
      writer.uint32(18).string(v!);
    }
    for (const v of message.records) {
      ChatRecord.encode(v!, writer.uint32(26).fork()).ldelim();
    }
    if (message.count !== 0) {
      writer.uint32(32).int64(message.count);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): GetRoomInfoResponse {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseGetRoomInfoResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.room = RoomInfo.decode(reader, reader.uint32());
          break;
        case 2:
          message.online_user_ids.push(reader.string());
          break;
        case 3:
          message.records.push(ChatRecord.decode(reader, reader.uint32()));
          break;
        case 4:
          message.count = longToNumber(reader.int64() as Long);
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): GetRoomInfoResponse {
    return {
      room: isSet(object.room) ? RoomInfo.fromJSON(object.room) : undefined,
      online_user_ids: Array.isArray(object?.online_user_ids)
        ? object.online_user_ids.map((e: any) => String(e))
        : [],
      records: Array.isArray(object?.records)
        ? object.records.map((e: any) => ChatRecord.fromJSON(e))
        : [],
      count: isSet(object.count) ? Number(object.count) : 0,
    };
  },

  toJSON(message: GetRoomInfoResponse): unknown {
    const obj: any = {};
    message.room !== undefined &&
      (obj.room = message.room ? RoomInfo.toJSON(message.room) : undefined);
    if (message.online_user_ids) {
      obj.online_user_ids = message.online_user_ids.map((e) => e);
    } else {
      obj.online_user_ids = [];
    }
    if (message.records) {
      obj.records = message.records.map((e) =>
        e ? ChatRecord.toJSON(e) : undefined
      );
    } else {
      obj.records = [];
    }
    message.count !== undefined && (obj.count = Math.round(message.count));
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<GetRoomInfoResponse>, I>>(
    object: I
  ): GetRoomInfoResponse {
    const message = createBaseGetRoomInfoResponse();
    message.room =
      object.room !== undefined && object.room !== null
        ? RoomInfo.fromPartial(object.room)
        : undefined;
    message.online_user_ids = object.online_user_ids?.map((e) => e) || [];
    message.records =
      object.records?.map((e) => ChatRecord.fromPartial(e)) || [];
    message.count = object.count ?? 0;
    return message;
  },
};

function createBaseGetRoomRecordsRequest(): GetRoomRecordsRequest {
  return {
    username: "",
    room_id: "",
    record_id: undefined,
    is_before: false,
    list_option: undefined,
  };
}

export const GetRoomRecordsRequest = {
  encode(
    message: GetRoomRecordsRequest,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.username !== "") {
      writer.uint32(10).string(message.username);
    }
    if (message.room_id !== "") {
      writer.uint32(18).string(message.room_id);
    }
    if (message.record_id !== undefined) {
      writer.uint32(26).string(message.record_id);
    }
    if (message.is_before === true) {
      writer.uint32(32).bool(message.is_before);
    }
    if (message.list_option !== undefined) {
      ListOption.encode(message.list_option, writer.uint32(42).fork()).ldelim();
    }
    return writer;
  },

  decode(
    input: _m0.Reader | Uint8Array,
    length?: number
  ): GetRoomRecordsRequest {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseGetRoomRecordsRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.username = reader.string();
          break;
        case 2:
          message.room_id = reader.string();
          break;
        case 3:
          message.record_id = reader.string();
          break;
        case 4:
          message.is_before = reader.bool();
          break;
        case 5:
          message.list_option = ListOption.decode(reader, reader.uint32());
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): GetRoomRecordsRequest {
    return {
      username: isSet(object.username) ? String(object.username) : "",
      room_id: isSet(object.room_id) ? String(object.room_id) : "",
      record_id: isSet(object.record_id) ? String(object.record_id) : undefined,
      is_before: isSet(object.is_before) ? Boolean(object.is_before) : false,
      list_option: isSet(object.list_option)
        ? ListOption.fromJSON(object.list_option)
        : undefined,
    };
  },

  toJSON(message: GetRoomRecordsRequest): unknown {
    const obj: any = {};
    message.username !== undefined && (obj.username = message.username);
    message.room_id !== undefined && (obj.room_id = message.room_id);
    message.record_id !== undefined && (obj.record_id = message.record_id);
    message.is_before !== undefined && (obj.is_before = message.is_before);
    message.list_option !== undefined &&
      (obj.list_option = message.list_option
        ? ListOption.toJSON(message.list_option)
        : undefined);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<GetRoomRecordsRequest>, I>>(
    object: I
  ): GetRoomRecordsRequest {
    const message = createBaseGetRoomRecordsRequest();
    message.username = object.username ?? "";
    message.room_id = object.room_id ?? "";
    message.record_id = object.record_id ?? undefined;
    message.is_before = object.is_before ?? false;
    message.list_option =
      object.list_option !== undefined && object.list_option !== null
        ? ListOption.fromPartial(object.list_option)
        : undefined;
    return message;
  },
};

function createBaseGetRoomRecordsResponse(): GetRoomRecordsResponse {
  return { records: [], count: 0 };
}

export const GetRoomRecordsResponse = {
  encode(
    message: GetRoomRecordsResponse,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    for (const v of message.records) {
      ChatRecord.encode(v!, writer.uint32(10).fork()).ldelim();
    }
    if (message.count !== 0) {
      writer.uint32(16).int64(message.count);
    }
    return writer;
  },

  decode(
    input: _m0.Reader | Uint8Array,
    length?: number
  ): GetRoomRecordsResponse {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseGetRoomRecordsResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.records.push(ChatRecord.decode(reader, reader.uint32()));
          break;
        case 2:
          message.count = longToNumber(reader.int64() as Long);
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): GetRoomRecordsResponse {
    return {
      records: Array.isArray(object?.records)
        ? object.records.map((e: any) => ChatRecord.fromJSON(e))
        : [],
      count: isSet(object.count) ? Number(object.count) : 0,
    };
  },

  toJSON(message: GetRoomRecordsResponse): unknown {
    const obj: any = {};
    if (message.records) {
      obj.records = message.records.map((e) =>
        e ? ChatRecord.toJSON(e) : undefined
      );
    } else {
      obj.records = [];
    }
    message.count !== undefined && (obj.count = Math.round(message.count));
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<GetRoomRecordsResponse>, I>>(
    object: I
  ): GetRoomRecordsResponse {
    const message = createBaseGetRoomRecordsResponse();
    message.records =
      object.records?.map((e) => ChatRecord.fromPartial(e)) || [];
    message.count = object.count ?? 0;
    return message;
  },
};

function createBaseCreateChatRoomRequest(): CreateChatRoomRequest {
  return { name: "", allow_user_ids: [], username: "" };
}

export const CreateChatRoomRequest = {
  encode(
    message: CreateChatRoomRequest,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.name !== "") {
      writer.uint32(10).string(message.name);
    }
    for (const v of message.allow_user_ids) {
      writer.uint32(18).string(v!);
    }
    if (message.username !== "") {
      writer.uint32(26).string(message.username);
    }
    return writer;
  },

  decode(
    input: _m0.Reader | Uint8Array,
    length?: number
  ): CreateChatRoomRequest {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseCreateChatRoomRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.name = reader.string();
          break;
        case 2:
          message.allow_user_ids.push(reader.string());
          break;
        case 3:
          message.username = reader.string();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): CreateChatRoomRequest {
    return {
      name: isSet(object.name) ? String(object.name) : "",
      allow_user_ids: Array.isArray(object?.allow_user_ids)
        ? object.allow_user_ids.map((e: any) => String(e))
        : [],
      username: isSet(object.username) ? String(object.username) : "",
    };
  },

  toJSON(message: CreateChatRoomRequest): unknown {
    const obj: any = {};
    message.name !== undefined && (obj.name = message.name);
    if (message.allow_user_ids) {
      obj.allow_user_ids = message.allow_user_ids.map((e) => e);
    } else {
      obj.allow_user_ids = [];
    }
    message.username !== undefined && (obj.username = message.username);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<CreateChatRoomRequest>, I>>(
    object: I
  ): CreateChatRoomRequest {
    const message = createBaseCreateChatRoomRequest();
    message.name = object.name ?? "";
    message.allow_user_ids = object.allow_user_ids?.map((e) => e) || [];
    message.username = object.username ?? "";
    return message;
  },
};

function createBaseUpdateChatRoomRequest(): UpdateChatRoomRequest {
  return { room_id: "", name: undefined, allow_user_ids: [], username: "" };
}

export const UpdateChatRoomRequest = {
  encode(
    message: UpdateChatRoomRequest,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.room_id !== "") {
      writer.uint32(10).string(message.room_id);
    }
    if (message.name !== undefined) {
      writer.uint32(18).string(message.name);
    }
    for (const v of message.allow_user_ids) {
      writer.uint32(26).string(v!);
    }
    if (message.username !== "") {
      writer.uint32(34).string(message.username);
    }
    return writer;
  },

  decode(
    input: _m0.Reader | Uint8Array,
    length?: number
  ): UpdateChatRoomRequest {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseUpdateChatRoomRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.room_id = reader.string();
          break;
        case 2:
          message.name = reader.string();
          break;
        case 3:
          message.allow_user_ids.push(reader.string());
          break;
        case 4:
          message.username = reader.string();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): UpdateChatRoomRequest {
    return {
      room_id: isSet(object.room_id) ? String(object.room_id) : "",
      name: isSet(object.name) ? String(object.name) : undefined,
      allow_user_ids: Array.isArray(object?.allow_user_ids)
        ? object.allow_user_ids.map((e: any) => String(e))
        : [],
      username: isSet(object.username) ? String(object.username) : "",
    };
  },

  toJSON(message: UpdateChatRoomRequest): unknown {
    const obj: any = {};
    message.room_id !== undefined && (obj.room_id = message.room_id);
    message.name !== undefined && (obj.name = message.name);
    if (message.allow_user_ids) {
      obj.allow_user_ids = message.allow_user_ids.map((e) => e);
    } else {
      obj.allow_user_ids = [];
    }
    message.username !== undefined && (obj.username = message.username);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<UpdateChatRoomRequest>, I>>(
    object: I
  ): UpdateChatRoomRequest {
    const message = createBaseUpdateChatRoomRequest();
    message.room_id = object.room_id ?? "";
    message.name = object.name ?? undefined;
    message.allow_user_ids = object.allow_user_ids?.map((e) => e) || [];
    message.username = object.username ?? "";
    return message;
  },
};

function createBaseDeleteChatRoomRequest(): DeleteChatRoomRequest {
  return { id: "", username: "" };
}

export const DeleteChatRoomRequest = {
  encode(
    message: DeleteChatRoomRequest,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.id !== "") {
      writer.uint32(10).string(message.id);
    }
    if (message.username !== "") {
      writer.uint32(18).string(message.username);
    }
    return writer;
  },

  decode(
    input: _m0.Reader | Uint8Array,
    length?: number
  ): DeleteChatRoomRequest {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseDeleteChatRoomRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.id = reader.string();
          break;
        case 2:
          message.username = reader.string();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): DeleteChatRoomRequest {
    return {
      id: isSet(object.id) ? String(object.id) : "",
      username: isSet(object.username) ? String(object.username) : "",
    };
  },

  toJSON(message: DeleteChatRoomRequest): unknown {
    const obj: any = {};
    message.id !== undefined && (obj.id = message.id);
    message.username !== undefined && (obj.username = message.username);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<DeleteChatRoomRequest>, I>>(
    object: I
  ): DeleteChatRoomRequest {
    const message = createBaseDeleteChatRoomRequest();
    message.id = object.id ?? "";
    message.username = object.username ?? "";
    return message;
  },
};

function createBasePushMessageRequest(): PushMessageRequest {
  return { message: [], to_user_ids: [], room_id: "", username: "" };
}

export const PushMessageRequest = {
  encode(
    message: PushMessageRequest,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    for (const v of message.message) {
      MsgInfo.encode(v!, writer.uint32(10).fork()).ldelim();
    }
    for (const v of message.to_user_ids) {
      writer.uint32(18).string(v!);
    }
    if (message.room_id !== "") {
      writer.uint32(26).string(message.room_id);
    }
    if (message.username !== "") {
      writer.uint32(34).string(message.username);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): PushMessageRequest {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBasePushMessageRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.message.push(MsgInfo.decode(reader, reader.uint32()));
          break;
        case 2:
          message.to_user_ids.push(reader.string());
          break;
        case 3:
          message.room_id = reader.string();
          break;
        case 4:
          message.username = reader.string();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): PushMessageRequest {
    return {
      message: Array.isArray(object?.message)
        ? object.message.map((e: any) => MsgInfo.fromJSON(e))
        : [],
      to_user_ids: Array.isArray(object?.to_user_ids)
        ? object.to_user_ids.map((e: any) => String(e))
        : [],
      room_id: isSet(object.room_id) ? String(object.room_id) : "",
      username: isSet(object.username) ? String(object.username) : "",
    };
  },

  toJSON(message: PushMessageRequest): unknown {
    const obj: any = {};
    if (message.message) {
      obj.message = message.message.map((e) =>
        e ? MsgInfo.toJSON(e) : undefined
      );
    } else {
      obj.message = [];
    }
    if (message.to_user_ids) {
      obj.to_user_ids = message.to_user_ids.map((e) => e);
    } else {
      obj.to_user_ids = [];
    }
    message.room_id !== undefined && (obj.room_id = message.room_id);
    message.username !== undefined && (obj.username = message.username);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<PushMessageRequest>, I>>(
    object: I
  ): PushMessageRequest {
    const message = createBasePushMessageRequest();
    message.message = object.message?.map((e) => MsgInfo.fromPartial(e)) || [];
    message.to_user_ids = object.to_user_ids?.map((e) => e) || [];
    message.room_id = object.room_id ?? "";
    message.username = object.username ?? "";
    return message;
  },
};

export interface Chat {
  GetOrgChatRooms(
    request: DeepPartial<GetOrgChatRoomsRequest>,
    metadata?: grpc.Metadata
  ): Promise<GetOrgChatRoomsResponse>;
  GetRoomInfo(
    request: DeepPartial<GetRoomInfoRequest>,
    metadata?: grpc.Metadata
  ): Promise<GetRoomInfoResponse>;
  GetRoomRecords(
    request: DeepPartial<GetRoomRecordsRequest>,
    metadata?: grpc.Metadata
  ): Promise<GetRoomRecordsResponse>;
  CreateChatRoom(
    request: DeepPartial<CreateChatRoomRequest>,
    metadata?: grpc.Metadata
  ): Promise<RoomInfo>;
  UpdateChatRoom(
    request: DeepPartial<UpdateChatRoomRequest>,
    metadata?: grpc.Metadata
  ): Promise<Empty>;
  DeleteChatRoom(
    request: DeepPartial<DeleteChatRoomRequest>,
    metadata?: grpc.Metadata
  ): Promise<Empty>;
  PushMessage(
    request: DeepPartial<PushMessageRequest>,
    metadata?: grpc.Metadata
  ): Promise<Empty>;
}

export class ChatClientImpl implements Chat {
  private readonly rpc: Rpc;

  constructor(rpc: Rpc) {
    this.rpc = rpc;
    this.GetOrgChatRooms = this.GetOrgChatRooms.bind(this);
    this.GetRoomInfo = this.GetRoomInfo.bind(this);
    this.GetRoomRecords = this.GetRoomRecords.bind(this);
    this.CreateChatRoom = this.CreateChatRoom.bind(this);
    this.UpdateChatRoom = this.UpdateChatRoom.bind(this);
    this.DeleteChatRoom = this.DeleteChatRoom.bind(this);
    this.PushMessage = this.PushMessage.bind(this);
  }

  GetOrgChatRooms(
    request: DeepPartial<GetOrgChatRoomsRequest>,
    metadata?: grpc.Metadata
  ): Promise<GetOrgChatRoomsResponse> {
    return this.rpc.unary(
      ChatGetOrgChatRoomsDesc,
      GetOrgChatRoomsRequest.fromPartial(request),
      metadata
    );
  }

  GetRoomInfo(
    request: DeepPartial<GetRoomInfoRequest>,
    metadata?: grpc.Metadata
  ): Promise<GetRoomInfoResponse> {
    return this.rpc.unary(
      ChatGetRoomInfoDesc,
      GetRoomInfoRequest.fromPartial(request),
      metadata
    );
  }

  GetRoomRecords(
    request: DeepPartial<GetRoomRecordsRequest>,
    metadata?: grpc.Metadata
  ): Promise<GetRoomRecordsResponse> {
    return this.rpc.unary(
      ChatGetRoomRecordsDesc,
      GetRoomRecordsRequest.fromPartial(request),
      metadata
    );
  }

  CreateChatRoom(
    request: DeepPartial<CreateChatRoomRequest>,
    metadata?: grpc.Metadata
  ): Promise<RoomInfo> {
    return this.rpc.unary(
      ChatCreateChatRoomDesc,
      CreateChatRoomRequest.fromPartial(request),
      metadata
    );
  }

  UpdateChatRoom(
    request: DeepPartial<UpdateChatRoomRequest>,
    metadata?: grpc.Metadata
  ): Promise<Empty> {
    return this.rpc.unary(
      ChatUpdateChatRoomDesc,
      UpdateChatRoomRequest.fromPartial(request),
      metadata
    );
  }

  DeleteChatRoom(
    request: DeepPartial<DeleteChatRoomRequest>,
    metadata?: grpc.Metadata
  ): Promise<Empty> {
    return this.rpc.unary(
      ChatDeleteChatRoomDesc,
      DeleteChatRoomRequest.fromPartial(request),
      metadata
    );
  }

  PushMessage(
    request: DeepPartial<PushMessageRequest>,
    metadata?: grpc.Metadata
  ): Promise<Empty> {
    return this.rpc.unary(
      ChatPushMessageDesc,
      PushMessageRequest.fromPartial(request),
      metadata
    );
  }
}

export const ChatDesc = {
  serviceName: "api.v1.Chat",
};

export const ChatGetOrgChatRoomsDesc: UnaryMethodDefinitionish = {
  methodName: "GetOrgChatRooms",
  service: ChatDesc,
  requestStream: false,
  responseStream: false,
  requestType: {
    serializeBinary() {
      return GetOrgChatRoomsRequest.encode(this).finish();
    },
  } as any,
  responseType: {
    deserializeBinary(data: Uint8Array) {
      return {
        ...GetOrgChatRoomsResponse.decode(data),
        toObject() {
          return this;
        },
      };
    },
  } as any,
};

export const ChatGetRoomInfoDesc: UnaryMethodDefinitionish = {
  methodName: "GetRoomInfo",
  service: ChatDesc,
  requestStream: false,
  responseStream: false,
  requestType: {
    serializeBinary() {
      return GetRoomInfoRequest.encode(this).finish();
    },
  } as any,
  responseType: {
    deserializeBinary(data: Uint8Array) {
      return {
        ...GetRoomInfoResponse.decode(data),
        toObject() {
          return this;
        },
      };
    },
  } as any,
};

export const ChatGetRoomRecordsDesc: UnaryMethodDefinitionish = {
  methodName: "GetRoomRecords",
  service: ChatDesc,
  requestStream: false,
  responseStream: false,
  requestType: {
    serializeBinary() {
      return GetRoomRecordsRequest.encode(this).finish();
    },
  } as any,
  responseType: {
    deserializeBinary(data: Uint8Array) {
      return {
        ...GetRoomRecordsResponse.decode(data),
        toObject() {
          return this;
        },
      };
    },
  } as any,
};

export const ChatCreateChatRoomDesc: UnaryMethodDefinitionish = {
  methodName: "CreateChatRoom",
  service: ChatDesc,
  requestStream: false,
  responseStream: false,
  requestType: {
    serializeBinary() {
      return CreateChatRoomRequest.encode(this).finish();
    },
  } as any,
  responseType: {
    deserializeBinary(data: Uint8Array) {
      return {
        ...RoomInfo.decode(data),
        toObject() {
          return this;
        },
      };
    },
  } as any,
};

export const ChatUpdateChatRoomDesc: UnaryMethodDefinitionish = {
  methodName: "UpdateChatRoom",
  service: ChatDesc,
  requestStream: false,
  responseStream: false,
  requestType: {
    serializeBinary() {
      return UpdateChatRoomRequest.encode(this).finish();
    },
  } as any,
  responseType: {
    deserializeBinary(data: Uint8Array) {
      return {
        ...Empty.decode(data),
        toObject() {
          return this;
        },
      };
    },
  } as any,
};

export const ChatDeleteChatRoomDesc: UnaryMethodDefinitionish = {
  methodName: "DeleteChatRoom",
  service: ChatDesc,
  requestStream: false,
  responseStream: false,
  requestType: {
    serializeBinary() {
      return DeleteChatRoomRequest.encode(this).finish();
    },
  } as any,
  responseType: {
    deserializeBinary(data: Uint8Array) {
      return {
        ...Empty.decode(data),
        toObject() {
          return this;
        },
      };
    },
  } as any,
};

export const ChatPushMessageDesc: UnaryMethodDefinitionish = {
  methodName: "PushMessage",
  service: ChatDesc,
  requestStream: false,
  responseStream: false,
  requestType: {
    serializeBinary() {
      return PushMessageRequest.encode(this).finish();
    },
  } as any,
  responseType: {
    deserializeBinary(data: Uint8Array) {
      return {
        ...Empty.decode(data),
        toObject() {
          return this;
        },
      };
    },
  } as any,
};

interface UnaryMethodDefinitionishR
  extends grpc.UnaryMethodDefinition<any, any> {
  requestStream: any;
  responseStream: any;
}

type UnaryMethodDefinitionish = UnaryMethodDefinitionishR;

interface Rpc {
  unary<T extends UnaryMethodDefinitionish>(
    methodDesc: T,
    request: any,
    metadata: grpc.Metadata | undefined
  ): Promise<any>;
}

export class GrpcWebImpl {
  private host: string;
  private options: {
    transport?: grpc.TransportFactory;

    debug?: boolean;
    metadata?: grpc.Metadata;
  };

  constructor(
    host: string,
    options: {
      transport?: grpc.TransportFactory;

      debug?: boolean;
      metadata?: grpc.Metadata;
    }
  ) {
    this.host = host;
    this.options = options;
  }

  unary<T extends UnaryMethodDefinitionish>(
    methodDesc: T,
    _request: any,
    metadata: grpc.Metadata | undefined
  ): Promise<any> {
    const request = { ..._request, ...methodDesc.requestType };
    const maybeCombinedMetadata =
      metadata && this.options.metadata
        ? new BrowserHeaders({
            ...this.options?.metadata.headersMap,
            ...metadata?.headersMap,
          })
        : metadata || this.options.metadata;
    return new Promise((resolve, reject) => {
      grpc.unary(methodDesc, {
        request,
        host: this.host,
        metadata: maybeCombinedMetadata,
        transport: this.options.transport,
        debug: this.options.debug,
        onEnd: function (response) {
          if (response.status === grpc.Code.OK) {
            resolve(response.message);
          } else {
            const err = new Error(response.statusMessage) as any;
            err.code = response.status;
            err.metadata = response.trailers;
            reject(err);
          }
        },
      });
    });
  }
}

declare var self: any | undefined;
declare var window: any | undefined;
declare var global: any | undefined;
var globalThis: any = (() => {
  if (typeof globalThis !== "undefined") return globalThis;
  if (typeof self !== "undefined") return self;
  if (typeof window !== "undefined") return window;
  if (typeof global !== "undefined") return global;
  throw "Unable to locate global object";
})();

type Builtin =
  | Date
  | Function
  | Uint8Array
  | string
  | number
  | boolean
  | undefined;

export type DeepPartial<T> = T extends Builtin
  ? T
  : T extends Array<infer U>
  ? Array<DeepPartial<U>>
  : T extends ReadonlyArray<infer U>
  ? ReadonlyArray<DeepPartial<U>>
  : T extends {}
  ? { [K in keyof T]?: DeepPartial<T[K]> }
  : Partial<T>;

type KeysOfUnion<T> = T extends T ? keyof T : never;
export type Exact<P, I extends P> = P extends Builtin
  ? P
  : P & { [K in keyof P]: Exact<P[K], I[K]> } & Record<
        Exclude<keyof I, KeysOfUnion<P>>,
        never
      >;

function longToNumber(long: Long): number {
  if (long.gt(Number.MAX_SAFE_INTEGER)) {
    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
  }
  return long.toNumber();
}

// If you get a compile-error about 'Constructor<Long> and ... have no overlap',
// add '--ts_proto_opt=esModuleInterop=true' as a flag when calling 'protoc'.
if (_m0.util.Long !== Long) {
  _m0.util.Long = Long as any;
  _m0.configure();
}

function isSet(value: any): boolean {
  return value !== null && value !== undefined;
}