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

export const protobufPackage = "api.v1";

export interface ApplyViaInvitationRequest {
  invitation_code: string;
  name?: string | undefined;
  mobile?: string | undefined;
  code?: string | undefined;
  user_id: string;
}

export interface OrgUserInvitee {
  id: number;
  uid: string;
  org_id: string;
  inviter_id: string;
  need_verify: boolean;
  email: string;
  org_name: string;
  user_name: string;
  full_name: string;
  inviter_name: string;
}

export interface GetOrgNeedVerifedInviteesResponse {
  invitees: OrgUserInvitee[];
}

export interface GetOrgUserInviteesResponse {
  OrgUserInvitees: OrgUserInvitee[];
}

export interface ApproveOrgInvitationRequest {
  org_id: string;
}

export interface RejectOrgInvitationRequest {
  org_id: string;
}

export interface OrgInvitationRequest {
  id: number;
}

export interface InviteUnRegisterMemberRequest {
  email: string;
  mobile: string;
  expires_at: number;
}

export interface VerifyInvitationCodeRequest {
  code: string;
  email: string;
}

export interface VerifyInvitationCodeResponse {
  redirect_url: string;
}

export interface InviteSearchRequest {
  keyword: string;
}

export interface Invitee {
  id: string;
  avatar: string;
  name: string;
  full_name: string;
}

export interface InviteSearchResponse {
  invitees: Invitee[];
}

export interface InviteMemberRequest {
  invited_username: string;
}

function createBaseApplyViaInvitationRequest(): ApplyViaInvitationRequest {
  return {
    invitation_code: "",
    name: undefined,
    mobile: undefined,
    code: undefined,
    user_id: "",
  };
}

export const ApplyViaInvitationRequest = {
  encode(
    message: ApplyViaInvitationRequest,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.invitation_code !== "") {
      writer.uint32(10).string(message.invitation_code);
    }
    if (message.name !== undefined) {
      writer.uint32(18).string(message.name);
    }
    if (message.mobile !== undefined) {
      writer.uint32(26).string(message.mobile);
    }
    if (message.code !== undefined) {
      writer.uint32(34).string(message.code);
    }
    if (message.user_id !== "") {
      writer.uint32(42).string(message.user_id);
    }
    return writer;
  },

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

  fromJSON(object: any): ApplyViaInvitationRequest {
    return {
      invitation_code: isSet(object.invitation_code)
        ? String(object.invitation_code)
        : "",
      name: isSet(object.name) ? String(object.name) : undefined,
      mobile: isSet(object.mobile) ? String(object.mobile) : undefined,
      code: isSet(object.code) ? String(object.code) : undefined,
      user_id: isSet(object.user_id) ? String(object.user_id) : "",
    };
  },

  toJSON(message: ApplyViaInvitationRequest): unknown {
    const obj: any = {};
    message.invitation_code !== undefined &&
      (obj.invitation_code = message.invitation_code);
    message.name !== undefined && (obj.name = message.name);
    message.mobile !== undefined && (obj.mobile = message.mobile);
    message.code !== undefined && (obj.code = message.code);
    message.user_id !== undefined && (obj.user_id = message.user_id);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<ApplyViaInvitationRequest>, I>>(
    object: I
  ): ApplyViaInvitationRequest {
    const message = createBaseApplyViaInvitationRequest();
    message.invitation_code = object.invitation_code ?? "";
    message.name = object.name ?? undefined;
    message.mobile = object.mobile ?? undefined;
    message.code = object.code ?? undefined;
    message.user_id = object.user_id ?? "";
    return message;
  },
};

function createBaseOrgUserInvitee(): OrgUserInvitee {
  return {
    id: 0,
    uid: "",
    org_id: "",
    inviter_id: "",
    need_verify: false,
    email: "",
    org_name: "",
    user_name: "",
    full_name: "",
    inviter_name: "",
  };
}

export const OrgUserInvitee = {
  encode(
    message: OrgUserInvitee,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.id !== 0) {
      writer.uint32(8).int64(message.id);
    }
    if (message.uid !== "") {
      writer.uint32(18).string(message.uid);
    }
    if (message.org_id !== "") {
      writer.uint32(26).string(message.org_id);
    }
    if (message.inviter_id !== "") {
      writer.uint32(34).string(message.inviter_id);
    }
    if (message.need_verify === true) {
      writer.uint32(40).bool(message.need_verify);
    }
    if (message.email !== "") {
      writer.uint32(50).string(message.email);
    }
    if (message.org_name !== "") {
      writer.uint32(58).string(message.org_name);
    }
    if (message.user_name !== "") {
      writer.uint32(66).string(message.user_name);
    }
    if (message.full_name !== "") {
      writer.uint32(74).string(message.full_name);
    }
    if (message.inviter_name !== "") {
      writer.uint32(82).string(message.inviter_name);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): OrgUserInvitee {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseOrgUserInvitee();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.id = longToNumber(reader.int64() as Long);
          break;
        case 2:
          message.uid = reader.string();
          break;
        case 3:
          message.org_id = reader.string();
          break;
        case 4:
          message.inviter_id = reader.string();
          break;
        case 5:
          message.need_verify = reader.bool();
          break;
        case 6:
          message.email = reader.string();
          break;
        case 7:
          message.org_name = reader.string();
          break;
        case 8:
          message.user_name = reader.string();
          break;
        case 9:
          message.full_name = reader.string();
          break;
        case 10:
          message.inviter_name = reader.string();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): OrgUserInvitee {
    return {
      id: isSet(object.id) ? Number(object.id) : 0,
      uid: isSet(object.uid) ? String(object.uid) : "",
      org_id: isSet(object.org_id) ? String(object.org_id) : "",
      inviter_id: isSet(object.inviter_id) ? String(object.inviter_id) : "",
      need_verify: isSet(object.need_verify)
        ? Boolean(object.need_verify)
        : false,
      email: isSet(object.email) ? String(object.email) : "",
      org_name: isSet(object.org_name) ? String(object.org_name) : "",
      user_name: isSet(object.user_name) ? String(object.user_name) : "",
      full_name: isSet(object.full_name) ? String(object.full_name) : "",
      inviter_name: isSet(object.inviter_name)
        ? String(object.inviter_name)
        : "",
    };
  },

  toJSON(message: OrgUserInvitee): unknown {
    const obj: any = {};
    message.id !== undefined && (obj.id = Math.round(message.id));
    message.uid !== undefined && (obj.uid = message.uid);
    message.org_id !== undefined && (obj.org_id = message.org_id);
    message.inviter_id !== undefined && (obj.inviter_id = message.inviter_id);
    message.need_verify !== undefined &&
      (obj.need_verify = message.need_verify);
    message.email !== undefined && (obj.email = message.email);
    message.org_name !== undefined && (obj.org_name = message.org_name);
    message.user_name !== undefined && (obj.user_name = message.user_name);
    message.full_name !== undefined && (obj.full_name = message.full_name);
    message.inviter_name !== undefined &&
      (obj.inviter_name = message.inviter_name);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<OrgUserInvitee>, I>>(
    object: I
  ): OrgUserInvitee {
    const message = createBaseOrgUserInvitee();
    message.id = object.id ?? 0;
    message.uid = object.uid ?? "";
    message.org_id = object.org_id ?? "";
    message.inviter_id = object.inviter_id ?? "";
    message.need_verify = object.need_verify ?? false;
    message.email = object.email ?? "";
    message.org_name = object.org_name ?? "";
    message.user_name = object.user_name ?? "";
    message.full_name = object.full_name ?? "";
    message.inviter_name = object.inviter_name ?? "";
    return message;
  },
};

function createBaseGetOrgNeedVerifedInviteesResponse(): GetOrgNeedVerifedInviteesResponse {
  return { invitees: [] };
}

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

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

  fromJSON(object: any): GetOrgNeedVerifedInviteesResponse {
    return {
      invitees: Array.isArray(object?.invitees)
        ? object.invitees.map((e: any) => OrgUserInvitee.fromJSON(e))
        : [],
    };
  },

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

  fromPartial<
    I extends Exact<DeepPartial<GetOrgNeedVerifedInviteesResponse>, I>
  >(object: I): GetOrgNeedVerifedInviteesResponse {
    const message = createBaseGetOrgNeedVerifedInviteesResponse();
    message.invitees =
      object.invitees?.map((e) => OrgUserInvitee.fromPartial(e)) || [];
    return message;
  },
};

function createBaseGetOrgUserInviteesResponse(): GetOrgUserInviteesResponse {
  return { OrgUserInvitees: [] };
}

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

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

  fromJSON(object: any): GetOrgUserInviteesResponse {
    return {
      OrgUserInvitees: Array.isArray(object?.OrgUserInvitees)
        ? object.OrgUserInvitees.map((e: any) => OrgUserInvitee.fromJSON(e))
        : [],
    };
  },

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

  fromPartial<I extends Exact<DeepPartial<GetOrgUserInviteesResponse>, I>>(
    object: I
  ): GetOrgUserInviteesResponse {
    const message = createBaseGetOrgUserInviteesResponse();
    message.OrgUserInvitees =
      object.OrgUserInvitees?.map((e) => OrgUserInvitee.fromPartial(e)) || [];
    return message;
  },
};

function createBaseApproveOrgInvitationRequest(): ApproveOrgInvitationRequest {
  return { org_id: "" };
}

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

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

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

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

  fromPartial<I extends Exact<DeepPartial<ApproveOrgInvitationRequest>, I>>(
    object: I
  ): ApproveOrgInvitationRequest {
    const message = createBaseApproveOrgInvitationRequest();
    message.org_id = object.org_id ?? "";
    return message;
  },
};

function createBaseRejectOrgInvitationRequest(): RejectOrgInvitationRequest {
  return { org_id: "" };
}

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

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

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

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

  fromPartial<I extends Exact<DeepPartial<RejectOrgInvitationRequest>, I>>(
    object: I
  ): RejectOrgInvitationRequest {
    const message = createBaseRejectOrgInvitationRequest();
    message.org_id = object.org_id ?? "";
    return message;
  },
};

function createBaseOrgInvitationRequest(): OrgInvitationRequest {
  return { id: 0 };
}

export const OrgInvitationRequest = {
  encode(
    message: OrgInvitationRequest,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.id !== 0) {
      writer.uint32(8).int64(message.id);
    }
    return writer;
  },

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

  fromJSON(object: any): OrgInvitationRequest {
    return {
      id: isSet(object.id) ? Number(object.id) : 0,
    };
  },

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

  fromPartial<I extends Exact<DeepPartial<OrgInvitationRequest>, I>>(
    object: I
  ): OrgInvitationRequest {
    const message = createBaseOrgInvitationRequest();
    message.id = object.id ?? 0;
    return message;
  },
};

function createBaseInviteUnRegisterMemberRequest(): InviteUnRegisterMemberRequest {
  return { email: "", mobile: "", expires_at: 0 };
}

export const InviteUnRegisterMemberRequest = {
  encode(
    message: InviteUnRegisterMemberRequest,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.email !== "") {
      writer.uint32(10).string(message.email);
    }
    if (message.mobile !== "") {
      writer.uint32(18).string(message.mobile);
    }
    if (message.expires_at !== 0) {
      writer.uint32(24).int64(message.expires_at);
    }
    return writer;
  },

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

  fromJSON(object: any): InviteUnRegisterMemberRequest {
    return {
      email: isSet(object.email) ? String(object.email) : "",
      mobile: isSet(object.mobile) ? String(object.mobile) : "",
      expires_at: isSet(object.expires_at) ? Number(object.expires_at) : 0,
    };
  },

  toJSON(message: InviteUnRegisterMemberRequest): unknown {
    const obj: any = {};
    message.email !== undefined && (obj.email = message.email);
    message.mobile !== undefined && (obj.mobile = message.mobile);
    message.expires_at !== undefined &&
      (obj.expires_at = Math.round(message.expires_at));
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<InviteUnRegisterMemberRequest>, I>>(
    object: I
  ): InviteUnRegisterMemberRequest {
    const message = createBaseInviteUnRegisterMemberRequest();
    message.email = object.email ?? "";
    message.mobile = object.mobile ?? "";
    message.expires_at = object.expires_at ?? 0;
    return message;
  },
};

function createBaseVerifyInvitationCodeRequest(): VerifyInvitationCodeRequest {
  return { code: "", email: "" };
}

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

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

  fromJSON(object: any): VerifyInvitationCodeRequest {
    return {
      code: isSet(object.code) ? String(object.code) : "",
      email: isSet(object.email) ? String(object.email) : "",
    };
  },

  toJSON(message: VerifyInvitationCodeRequest): unknown {
    const obj: any = {};
    message.code !== undefined && (obj.code = message.code);
    message.email !== undefined && (obj.email = message.email);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<VerifyInvitationCodeRequest>, I>>(
    object: I
  ): VerifyInvitationCodeRequest {
    const message = createBaseVerifyInvitationCodeRequest();
    message.code = object.code ?? "";
    message.email = object.email ?? "";
    return message;
  },
};

function createBaseVerifyInvitationCodeResponse(): VerifyInvitationCodeResponse {
  return { redirect_url: "" };
}

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

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

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

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

  fromPartial<I extends Exact<DeepPartial<VerifyInvitationCodeResponse>, I>>(
    object: I
  ): VerifyInvitationCodeResponse {
    const message = createBaseVerifyInvitationCodeResponse();
    message.redirect_url = object.redirect_url ?? "";
    return message;
  },
};

function createBaseInviteSearchRequest(): InviteSearchRequest {
  return { keyword: "" };
}

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

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

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

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

  fromPartial<I extends Exact<DeepPartial<InviteSearchRequest>, I>>(
    object: I
  ): InviteSearchRequest {
    const message = createBaseInviteSearchRequest();
    message.keyword = object.keyword ?? "";
    return message;
  },
};

function createBaseInvitee(): Invitee {
  return { id: "", avatar: "", name: "", full_name: "" };
}

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

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

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

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

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

function createBaseInviteSearchResponse(): InviteSearchResponse {
  return { invitees: [] };
}

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

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

  fromJSON(object: any): InviteSearchResponse {
    return {
      invitees: Array.isArray(object?.invitees)
        ? object.invitees.map((e: any) => Invitee.fromJSON(e))
        : [],
    };
  },

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

  fromPartial<I extends Exact<DeepPartial<InviteSearchResponse>, I>>(
    object: I
  ): InviteSearchResponse {
    const message = createBaseInviteSearchResponse();
    message.invitees =
      object.invitees?.map((e) => Invitee.fromPartial(e)) || [];
    return message;
  },
};

function createBaseInviteMemberRequest(): InviteMemberRequest {
  return { invited_username: "" };
}

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

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

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

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

  fromPartial<I extends Exact<DeepPartial<InviteMemberRequest>, I>>(
    object: I
  ): InviteMemberRequest {
    const message = createBaseInviteMemberRequest();
    message.invited_username = object.invited_username ?? "";
    return message;
  },
};

export interface Invitation {
  ApplyViaInvitation(
    request: DeepPartial<ApplyViaInvitationRequest>,
    metadata?: grpc.Metadata
  ): Promise<Empty>;
  GetOrgNeedVerifedInvitees(
    request: DeepPartial<Empty>,
    metadata?: grpc.Metadata
  ): Promise<GetOrgNeedVerifedInviteesResponse>;
  /** 他人申请，拒绝加入组织 */
  DenyOrgInvitation(
    request: DeepPartial<OrgInvitationRequest>,
    metadata?: grpc.Metadata
  ): Promise<Empty>;
  /** 他人申请，同意加入组织 */
  ApproveJoinOrgApply(
    request: DeepPartial<OrgInvitationRequest>,
    metadata?: grpc.Metadata
  ): Promise<Empty>;
  GetOrgUserInvitees(
    request: DeepPartial<Empty>,
    metadata?: grpc.Metadata
  ): Promise<GetOrgUserInviteesResponse>;
  ApproveOrgInvitation(
    request: DeepPartial<ApproveOrgInvitationRequest>,
    metadata?: grpc.Metadata
  ): Promise<Empty>;
  RejectOrgInvitation(
    request: DeepPartial<RejectOrgInvitationRequest>,
    metadata?: grpc.Metadata
  ): Promise<Empty>;
  InviteUnRegisterMember(
    request: DeepPartial<InviteUnRegisterMemberRequest>,
    metadata?: grpc.Metadata
  ): Promise<Empty>;
  VerifyInvitationCode(
    request: DeepPartial<VerifyInvitationCodeRequest>,
    metadata?: grpc.Metadata
  ): Promise<VerifyInvitationCodeResponse>;
  InviteSearch(
    request: DeepPartial<InviteSearchRequest>,
    metadata?: grpc.Metadata
  ): Promise<InviteSearchResponse>;
  InviteMember(
    request: DeepPartial<InviteMemberRequest>,
    metadata?: grpc.Metadata
  ): Promise<OrgMember>;
}

export class InvitationClientImpl implements Invitation {
  private readonly rpc: Rpc;

  constructor(rpc: Rpc) {
    this.rpc = rpc;
    this.ApplyViaInvitation = this.ApplyViaInvitation.bind(this);
    this.GetOrgNeedVerifedInvitees = this.GetOrgNeedVerifedInvitees.bind(this);
    this.DenyOrgInvitation = this.DenyOrgInvitation.bind(this);
    this.ApproveJoinOrgApply = this.ApproveJoinOrgApply.bind(this);
    this.GetOrgUserInvitees = this.GetOrgUserInvitees.bind(this);
    this.ApproveOrgInvitation = this.ApproveOrgInvitation.bind(this);
    this.RejectOrgInvitation = this.RejectOrgInvitation.bind(this);
    this.InviteUnRegisterMember = this.InviteUnRegisterMember.bind(this);
    this.VerifyInvitationCode = this.VerifyInvitationCode.bind(this);
    this.InviteSearch = this.InviteSearch.bind(this);
    this.InviteMember = this.InviteMember.bind(this);
  }

  ApplyViaInvitation(
    request: DeepPartial<ApplyViaInvitationRequest>,
    metadata?: grpc.Metadata
  ): Promise<Empty> {
    return this.rpc.unary(
      InvitationApplyViaInvitationDesc,
      ApplyViaInvitationRequest.fromPartial(request),
      metadata
    );
  }

  GetOrgNeedVerifedInvitees(
    request: DeepPartial<Empty>,
    metadata?: grpc.Metadata
  ): Promise<GetOrgNeedVerifedInviteesResponse> {
    return this.rpc.unary(
      InvitationGetOrgNeedVerifedInviteesDesc,
      Empty.fromPartial(request),
      metadata
    );
  }

  DenyOrgInvitation(
    request: DeepPartial<OrgInvitationRequest>,
    metadata?: grpc.Metadata
  ): Promise<Empty> {
    return this.rpc.unary(
      InvitationDenyOrgInvitationDesc,
      OrgInvitationRequest.fromPartial(request),
      metadata
    );
  }

  ApproveJoinOrgApply(
    request: DeepPartial<OrgInvitationRequest>,
    metadata?: grpc.Metadata
  ): Promise<Empty> {
    return this.rpc.unary(
      InvitationApproveJoinOrgApplyDesc,
      OrgInvitationRequest.fromPartial(request),
      metadata
    );
  }

  GetOrgUserInvitees(
    request: DeepPartial<Empty>,
    metadata?: grpc.Metadata
  ): Promise<GetOrgUserInviteesResponse> {
    return this.rpc.unary(
      InvitationGetOrgUserInviteesDesc,
      Empty.fromPartial(request),
      metadata
    );
  }

  ApproveOrgInvitation(
    request: DeepPartial<ApproveOrgInvitationRequest>,
    metadata?: grpc.Metadata
  ): Promise<Empty> {
    return this.rpc.unary(
      InvitationApproveOrgInvitationDesc,
      ApproveOrgInvitationRequest.fromPartial(request),
      metadata
    );
  }

  RejectOrgInvitation(
    request: DeepPartial<RejectOrgInvitationRequest>,
    metadata?: grpc.Metadata
  ): Promise<Empty> {
    return this.rpc.unary(
      InvitationRejectOrgInvitationDesc,
      RejectOrgInvitationRequest.fromPartial(request),
      metadata
    );
  }

  InviteUnRegisterMember(
    request: DeepPartial<InviteUnRegisterMemberRequest>,
    metadata?: grpc.Metadata
  ): Promise<Empty> {
    return this.rpc.unary(
      InvitationInviteUnRegisterMemberDesc,
      InviteUnRegisterMemberRequest.fromPartial(request),
      metadata
    );
  }

  VerifyInvitationCode(
    request: DeepPartial<VerifyInvitationCodeRequest>,
    metadata?: grpc.Metadata
  ): Promise<VerifyInvitationCodeResponse> {
    return this.rpc.unary(
      InvitationVerifyInvitationCodeDesc,
      VerifyInvitationCodeRequest.fromPartial(request),
      metadata
    );
  }

  InviteSearch(
    request: DeepPartial<InviteSearchRequest>,
    metadata?: grpc.Metadata
  ): Promise<InviteSearchResponse> {
    return this.rpc.unary(
      InvitationInviteSearchDesc,
      InviteSearchRequest.fromPartial(request),
      metadata
    );
  }

  InviteMember(
    request: DeepPartial<InviteMemberRequest>,
    metadata?: grpc.Metadata
  ): Promise<OrgMember> {
    return this.rpc.unary(
      InvitationInviteMemberDesc,
      InviteMemberRequest.fromPartial(request),
      metadata
    );
  }
}

export const InvitationDesc = {
  serviceName: "api.v1.Invitation",
};

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

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

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

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

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

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

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

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

export const InvitationVerifyInvitationCodeDesc: UnaryMethodDefinitionish = {
  methodName: "VerifyInvitationCode",
  service: InvitationDesc,
  requestStream: false,
  responseStream: false,
  requestType: {
    serializeBinary() {
      return VerifyInvitationCodeRequest.encode(this).finish();
    },
  } as any,
  responseType: {
    deserializeBinary(data: Uint8Array) {
      return {
        ...VerifyInvitationCodeResponse.decode(data),
        toObject() {
          return this;
        },
      };
    },
  } as any,
};

export const InvitationInviteSearchDesc: UnaryMethodDefinitionish = {
  methodName: "InviteSearch",
  service: InvitationDesc,
  requestStream: false,
  responseStream: false,
  requestType: {
    serializeBinary() {
      return InviteSearchRequest.encode(this).finish();
    },
  } as any,
  responseType: {
    deserializeBinary(data: Uint8Array) {
      return {
        ...InviteSearchResponse.decode(data),
        toObject() {
          return this;
        },
      };
    },
  } as any,
};

export const InvitationInviteMemberDesc: UnaryMethodDefinitionish = {
  methodName: "InviteMember",
  service: InvitationDesc,
  requestStream: false,
  responseStream: false,
  requestType: {
    serializeBinary() {
      return InviteMemberRequest.encode(this).finish();
    },
  } as any,
  responseType: {
    deserializeBinary(data: Uint8Array) {
      return {
        ...OrgMember.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;
}