// @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 { BrowserHeaders } from "browser-headers";
import { Struct } from "./google/protobuf/struct";

export const protobufPackage = "api.v1";

export interface BindInfo {
  id: number;
  user_id: string;
  org_id: string;
  type: number;
  meta: string;
}

export interface MemberTeamInfo {
  uid: string;
  team_ids: number[];
  user_name: string;
  avatar: string;
}

export interface OrgMember {
  id: number;
  user_id: string;
  user_name: string;
  avatar: string;
  avatar_email: string;
  user_mobile: string;
  invite: boolean;
  is_user_org_owner: boolean;
  user_email: string;
  is_admin: boolean;
  full_name: string;
}

export interface GetOrgBindAppRequest {
  username: string;
}

export interface GetOrgMemberTeamsRequest {
  username: string;
}

export interface GetOrgBindAppResponse {
  binds: BindInfo[];
}

export interface GetOrgMemberTeamsResponse {
  memberTeams: MemberTeamInfo[];
}

export interface GetOrgMembersRequest {
  search_word: string;
}

export interface GetOrgMembersResponse {
  members: OrgMember[];
  total: number;
}

export interface RemoveOrgMembersRequest {
  id: number;
  ids: number[];
}

export interface OnlineResponse {
  onlines: Online[];
}

export interface Online {
  userid: string;
  presence: Presence;
}

export interface Presence {
  status: number;
  last_online: string;
}

export interface GetHooksResponse {
  hooks: Hook[];
}

export interface Hook {
  id: number;
  type: string;
  url: string;
  config: { [key: string]: any } | undefined;
  events: string[];
  hook_desc: HookEvent;
  active: boolean;
  updated_at: number;
  created_at: number;
}

export interface HookEvent {
  push_only: boolean;
  send_everything: boolean;
  choose_events: boolean;
}

export interface HookOption {
  id: number;
  type: string;
  events: string[];
  event_type: string;
  active: boolean;
  config: { [key: string]: any } | undefined;
}

export interface DeleteHookRequest {
  id: number;
}

function createBaseBindInfo(): BindInfo {
  return { id: 0, user_id: "", org_id: "", type: 0, meta: "" };
}

export const BindInfo = {
  encode(
    message: BindInfo,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.id !== 0) {
      writer.uint32(8).int64(message.id);
    }
    if (message.user_id !== "") {
      writer.uint32(18).string(message.user_id);
    }
    if (message.org_id !== "") {
      writer.uint32(26).string(message.org_id);
    }
    if (message.type !== 0) {
      writer.uint32(32).int32(message.type);
    }
    if (message.meta !== "") {
      writer.uint32(42).string(message.meta);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): BindInfo {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseBindInfo();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.id = longToNumber(reader.int64() as Long);
          break;
        case 2:
          message.user_id = reader.string();
          break;
        case 3:
          message.org_id = reader.string();
          break;
        case 4:
          message.type = reader.int32();
          break;
        case 5:
          message.meta = reader.string();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): BindInfo {
    return {
      id: isSet(object.id) ? Number(object.id) : 0,
      user_id: isSet(object.user_id) ? String(object.user_id) : "",
      org_id: isSet(object.org_id) ? String(object.org_id) : "",
      type: isSet(object.type) ? Number(object.type) : 0,
      meta: isSet(object.meta) ? String(object.meta) : "",
    };
  },

  toJSON(message: BindInfo): unknown {
    const obj: any = {};
    message.id !== undefined && (obj.id = Math.round(message.id));
    message.user_id !== undefined && (obj.user_id = message.user_id);
    message.org_id !== undefined && (obj.org_id = message.org_id);
    message.type !== undefined && (obj.type = Math.round(message.type));
    message.meta !== undefined && (obj.meta = message.meta);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<BindInfo>, I>>(object: I): BindInfo {
    const message = createBaseBindInfo();
    message.id = object.id ?? 0;
    message.user_id = object.user_id ?? "";
    message.org_id = object.org_id ?? "";
    message.type = object.type ?? 0;
    message.meta = object.meta ?? "";
    return message;
  },
};

function createBaseMemberTeamInfo(): MemberTeamInfo {
  return { uid: "", team_ids: [], user_name: "", avatar: "" };
}

export const MemberTeamInfo = {
  encode(
    message: MemberTeamInfo,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.uid !== "") {
      writer.uint32(10).string(message.uid);
    }
    writer.uint32(18).fork();
    for (const v of message.team_ids) {
      writer.int64(v);
    }
    writer.ldelim();
    if (message.user_name !== "") {
      writer.uint32(26).string(message.user_name);
    }
    if (message.avatar !== "") {
      writer.uint32(34).string(message.avatar);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): MemberTeamInfo {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseMemberTeamInfo();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.uid = reader.string();
          break;
        case 2:
          if ((tag & 7) === 2) {
            const end2 = reader.uint32() + reader.pos;
            while (reader.pos < end2) {
              message.team_ids.push(longToNumber(reader.int64() as Long));
            }
          } else {
            message.team_ids.push(longToNumber(reader.int64() as Long));
          }
          break;
        case 3:
          message.user_name = reader.string();
          break;
        case 4:
          message.avatar = reader.string();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): MemberTeamInfo {
    return {
      uid: isSet(object.uid) ? String(object.uid) : "",
      team_ids: Array.isArray(object?.team_ids)
        ? object.team_ids.map((e: any) => Number(e))
        : [],
      user_name: isSet(object.user_name) ? String(object.user_name) : "",
      avatar: isSet(object.avatar) ? String(object.avatar) : "",
    };
  },

  toJSON(message: MemberTeamInfo): unknown {
    const obj: any = {};
    message.uid !== undefined && (obj.uid = message.uid);
    if (message.team_ids) {
      obj.team_ids = message.team_ids.map((e) => Math.round(e));
    } else {
      obj.team_ids = [];
    }
    message.user_name !== undefined && (obj.user_name = message.user_name);
    message.avatar !== undefined && (obj.avatar = message.avatar);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<MemberTeamInfo>, I>>(
    object: I
  ): MemberTeamInfo {
    const message = createBaseMemberTeamInfo();
    message.uid = object.uid ?? "";
    message.team_ids = object.team_ids?.map((e) => e) || [];
    message.user_name = object.user_name ?? "";
    message.avatar = object.avatar ?? "";
    return message;
  },
};

function createBaseOrgMember(): OrgMember {
  return {
    id: 0,
    user_id: "",
    user_name: "",
    avatar: "",
    avatar_email: "",
    user_mobile: "",
    invite: false,
    is_user_org_owner: false,
    user_email: "",
    is_admin: false,
    full_name: "",
  };
}

export const OrgMember = {
  encode(
    message: OrgMember,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.id !== 0) {
      writer.uint32(8).int64(message.id);
    }
    if (message.user_id !== "") {
      writer.uint32(18).string(message.user_id);
    }
    if (message.user_name !== "") {
      writer.uint32(26).string(message.user_name);
    }
    if (message.avatar !== "") {
      writer.uint32(34).string(message.avatar);
    }
    if (message.avatar_email !== "") {
      writer.uint32(42).string(message.avatar_email);
    }
    if (message.user_mobile !== "") {
      writer.uint32(50).string(message.user_mobile);
    }
    if (message.invite === true) {
      writer.uint32(56).bool(message.invite);
    }
    if (message.is_user_org_owner === true) {
      writer.uint32(64).bool(message.is_user_org_owner);
    }
    if (message.user_email !== "") {
      writer.uint32(74).string(message.user_email);
    }
    if (message.is_admin === true) {
      writer.uint32(80).bool(message.is_admin);
    }
    if (message.full_name !== "") {
      writer.uint32(90).string(message.full_name);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): OrgMember {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseOrgMember();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.id = longToNumber(reader.int64() as Long);
          break;
        case 2:
          message.user_id = reader.string();
          break;
        case 3:
          message.user_name = reader.string();
          break;
        case 4:
          message.avatar = reader.string();
          break;
        case 5:
          message.avatar_email = reader.string();
          break;
        case 6:
          message.user_mobile = reader.string();
          break;
        case 7:
          message.invite = reader.bool();
          break;
        case 8:
          message.is_user_org_owner = reader.bool();
          break;
        case 9:
          message.user_email = reader.string();
          break;
        case 10:
          message.is_admin = reader.bool();
          break;
        case 11:
          message.full_name = reader.string();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): OrgMember {
    return {
      id: isSet(object.id) ? Number(object.id) : 0,
      user_id: isSet(object.user_id) ? String(object.user_id) : "",
      user_name: isSet(object.user_name) ? String(object.user_name) : "",
      avatar: isSet(object.avatar) ? String(object.avatar) : "",
      avatar_email: isSet(object.avatar_email)
        ? String(object.avatar_email)
        : "",
      user_mobile: isSet(object.user_mobile) ? String(object.user_mobile) : "",
      invite: isSet(object.invite) ? Boolean(object.invite) : false,
      is_user_org_owner: isSet(object.is_user_org_owner)
        ? Boolean(object.is_user_org_owner)
        : false,
      user_email: isSet(object.user_email) ? String(object.user_email) : "",
      is_admin: isSet(object.is_admin) ? Boolean(object.is_admin) : false,
      full_name: isSet(object.full_name) ? String(object.full_name) : "",
    };
  },

  toJSON(message: OrgMember): unknown {
    const obj: any = {};
    message.id !== undefined && (obj.id = Math.round(message.id));
    message.user_id !== undefined && (obj.user_id = message.user_id);
    message.user_name !== undefined && (obj.user_name = message.user_name);
    message.avatar !== undefined && (obj.avatar = message.avatar);
    message.avatar_email !== undefined &&
      (obj.avatar_email = message.avatar_email);
    message.user_mobile !== undefined &&
      (obj.user_mobile = message.user_mobile);
    message.invite !== undefined && (obj.invite = message.invite);
    message.is_user_org_owner !== undefined &&
      (obj.is_user_org_owner = message.is_user_org_owner);
    message.user_email !== undefined && (obj.user_email = message.user_email);
    message.is_admin !== undefined && (obj.is_admin = message.is_admin);
    message.full_name !== undefined && (obj.full_name = message.full_name);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<OrgMember>, I>>(
    object: I
  ): OrgMember {
    const message = createBaseOrgMember();
    message.id = object.id ?? 0;
    message.user_id = object.user_id ?? "";
    message.user_name = object.user_name ?? "";
    message.avatar = object.avatar ?? "";
    message.avatar_email = object.avatar_email ?? "";
    message.user_mobile = object.user_mobile ?? "";
    message.invite = object.invite ?? false;
    message.is_user_org_owner = object.is_user_org_owner ?? false;
    message.user_email = object.user_email ?? "";
    message.is_admin = object.is_admin ?? false;
    message.full_name = object.full_name ?? "";
    return message;
  },
};

function createBaseGetOrgBindAppRequest(): GetOrgBindAppRequest {
  return { username: "" };
}

export const GetOrgBindAppRequest = {
  encode(
    message: GetOrgBindAppRequest,
    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
  ): GetOrgBindAppRequest {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseGetOrgBindAppRequest();
    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): GetOrgBindAppRequest {
    return {
      username: isSet(object.username) ? String(object.username) : "",
    };
  },

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

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

function createBaseGetOrgMemberTeamsRequest(): GetOrgMemberTeamsRequest {
  return { username: "" };
}

export const GetOrgMemberTeamsRequest = {
  encode(
    message: GetOrgMemberTeamsRequest,
    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
  ): GetOrgMemberTeamsRequest {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseGetOrgMemberTeamsRequest();
    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): GetOrgMemberTeamsRequest {
    return {
      username: isSet(object.username) ? String(object.username) : "",
    };
  },

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

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

function createBaseGetOrgBindAppResponse(): GetOrgBindAppResponse {
  return { binds: [] };
}

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

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

  fromJSON(object: any): GetOrgBindAppResponse {
    return {
      binds: Array.isArray(object?.binds)
        ? object.binds.map((e: any) => BindInfo.fromJSON(e))
        : [],
    };
  },

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

  fromPartial<I extends Exact<DeepPartial<GetOrgBindAppResponse>, I>>(
    object: I
  ): GetOrgBindAppResponse {
    const message = createBaseGetOrgBindAppResponse();
    message.binds = object.binds?.map((e) => BindInfo.fromPartial(e)) || [];
    return message;
  },
};

function createBaseGetOrgMemberTeamsResponse(): GetOrgMemberTeamsResponse {
  return { memberTeams: [] };
}

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

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

  fromJSON(object: any): GetOrgMemberTeamsResponse {
    return {
      memberTeams: Array.isArray(object?.memberTeams)
        ? object.memberTeams.map((e: any) => MemberTeamInfo.fromJSON(e))
        : [],
    };
  },

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

  fromPartial<I extends Exact<DeepPartial<GetOrgMemberTeamsResponse>, I>>(
    object: I
  ): GetOrgMemberTeamsResponse {
    const message = createBaseGetOrgMemberTeamsResponse();
    message.memberTeams =
      object.memberTeams?.map((e) => MemberTeamInfo.fromPartial(e)) || [];
    return message;
  },
};

function createBaseGetOrgMembersRequest(): GetOrgMembersRequest {
  return { search_word: "" };
}

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

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

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

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

  fromPartial<I extends Exact<DeepPartial<GetOrgMembersRequest>, I>>(
    object: I
  ): GetOrgMembersRequest {
    const message = createBaseGetOrgMembersRequest();
    message.search_word = object.search_word ?? "";
    return message;
  },
};

function createBaseGetOrgMembersResponse(): GetOrgMembersResponse {
  return { members: [], total: 0 };
}

export const GetOrgMembersResponse = {
  encode(
    message: GetOrgMembersResponse,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    for (const v of message.members) {
      OrgMember.encode(v!, writer.uint32(10).fork()).ldelim();
    }
    if (message.total !== 0) {
      writer.uint32(16).int64(message.total);
    }
    return writer;
  },

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

  fromJSON(object: any): GetOrgMembersResponse {
    return {
      members: Array.isArray(object?.members)
        ? object.members.map((e: any) => OrgMember.fromJSON(e))
        : [],
      total: isSet(object.total) ? Number(object.total) : 0,
    };
  },

  toJSON(message: GetOrgMembersResponse): unknown {
    const obj: any = {};
    if (message.members) {
      obj.members = message.members.map((e) =>
        e ? OrgMember.toJSON(e) : undefined
      );
    } else {
      obj.members = [];
    }
    message.total !== undefined && (obj.total = Math.round(message.total));
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<GetOrgMembersResponse>, I>>(
    object: I
  ): GetOrgMembersResponse {
    const message = createBaseGetOrgMembersResponse();
    message.members =
      object.members?.map((e) => OrgMember.fromPartial(e)) || [];
    message.total = object.total ?? 0;
    return message;
  },
};

function createBaseRemoveOrgMembersRequest(): RemoveOrgMembersRequest {
  return { id: 0, ids: [] };
}

export const RemoveOrgMembersRequest = {
  encode(
    message: RemoveOrgMembersRequest,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.id !== 0) {
      writer.uint32(8).int64(message.id);
    }
    writer.uint32(18).fork();
    for (const v of message.ids) {
      writer.int64(v);
    }
    writer.ldelim();
    return writer;
  },

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

  fromJSON(object: any): RemoveOrgMembersRequest {
    return {
      id: isSet(object.id) ? Number(object.id) : 0,
      ids: Array.isArray(object?.ids)
        ? object.ids.map((e: any) => Number(e))
        : [],
    };
  },

  toJSON(message: RemoveOrgMembersRequest): unknown {
    const obj: any = {};
    message.id !== undefined && (obj.id = Math.round(message.id));
    if (message.ids) {
      obj.ids = message.ids.map((e) => Math.round(e));
    } else {
      obj.ids = [];
    }
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<RemoveOrgMembersRequest>, I>>(
    object: I
  ): RemoveOrgMembersRequest {
    const message = createBaseRemoveOrgMembersRequest();
    message.id = object.id ?? 0;
    message.ids = object.ids?.map((e) => e) || [];
    return message;
  },
};

function createBaseOnlineResponse(): OnlineResponse {
  return { onlines: [] };
}

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

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

  fromJSON(object: any): OnlineResponse {
    return {
      onlines: Array.isArray(object?.onlines)
        ? object.onlines.map((e: any) => Online.fromJSON(e))
        : [],
    };
  },

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

  fromPartial<I extends Exact<DeepPartial<OnlineResponse>, I>>(
    object: I
  ): OnlineResponse {
    const message = createBaseOnlineResponse();
    message.onlines = object.onlines?.map((e) => Online.fromPartial(e)) || [];
    return message;
  },
};

function createBaseOnline(): Online {
  return { userid: "", presence: undefined };
}

export const Online = {
  encode(
    message: Online,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.userid !== "") {
      writer.uint32(10).string(message.userid);
    }
    if (message.presence !== undefined) {
      Presence.encode(message.presence, writer.uint32(18).fork()).ldelim();
    }
    return writer;
  },

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

  fromJSON(object: any): Online {
    return {
      userid: isSet(object.userid) ? String(object.userid) : "",
      presence: isSet(object.presence)
        ? Presence.fromJSON(object.presence)
        : undefined,
    };
  },

  toJSON(message: Online): unknown {
    const obj: any = {};
    message.userid !== undefined && (obj.userid = message.userid);
    message.presence !== undefined &&
      (obj.presence = message.presence
        ? Presence.toJSON(message.presence)
        : undefined);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<Online>, I>>(object: I): Online {
    const message = createBaseOnline();
    message.userid = object.userid ?? "";
    message.presence =
      object.presence !== undefined && object.presence !== null
        ? Presence.fromPartial(object.presence)
        : undefined;
    return message;
  },
};

function createBasePresence(): Presence {
  return { status: 0, last_online: "" };
}

export const Presence = {
  encode(
    message: Presence,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.status !== 0) {
      writer.uint32(8).int32(message.status);
    }
    if (message.last_online !== "") {
      writer.uint32(18).string(message.last_online);
    }
    return writer;
  },

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

  fromJSON(object: any): Presence {
    return {
      status: isSet(object.status) ? Number(object.status) : 0,
      last_online: isSet(object.last_online) ? String(object.last_online) : "",
    };
  },

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

  fromPartial<I extends Exact<DeepPartial<Presence>, I>>(object: I): Presence {
    const message = createBasePresence();
    message.status = object.status ?? 0;
    message.last_online = object.last_online ?? "";
    return message;
  },
};

function createBaseGetHooksResponse(): GetHooksResponse {
  return { hooks: [] };
}

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

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

  fromJSON(object: any): GetHooksResponse {
    return {
      hooks: Array.isArray(object?.hooks)
        ? object.hooks.map((e: any) => Hook.fromJSON(e))
        : [],
    };
  },

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

  fromPartial<I extends Exact<DeepPartial<GetHooksResponse>, I>>(
    object: I
  ): GetHooksResponse {
    const message = createBaseGetHooksResponse();
    message.hooks = object.hooks?.map((e) => Hook.fromPartial(e)) || [];
    return message;
  },
};

function createBaseHook(): Hook {
  return {
    id: 0,
    type: "",
    url: "",
    config: undefined,
    events: [],
    hook_desc: undefined,
    active: false,
    updated_at: 0,
    created_at: 0,
  };
}

export const Hook = {
  encode(message: Hook, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.id !== 0) {
      writer.uint32(8).int64(message.id);
    }
    if (message.type !== "") {
      writer.uint32(18).string(message.type);
    }
    if (message.url !== "") {
      writer.uint32(26).string(message.url);
    }
    if (message.config !== undefined) {
      Struct.encode(
        Struct.wrap(message.config),
        writer.uint32(34).fork()
      ).ldelim();
    }
    for (const v of message.events) {
      writer.uint32(42).string(v!);
    }
    if (message.hook_desc !== undefined) {
      HookEvent.encode(message.hook_desc, writer.uint32(50).fork()).ldelim();
    }
    if (message.active === true) {
      writer.uint32(56).bool(message.active);
    }
    if (message.updated_at !== 0) {
      writer.uint32(64).int64(message.updated_at);
    }
    if (message.created_at !== 0) {
      writer.uint32(80).int64(message.created_at);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): Hook {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseHook();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.id = longToNumber(reader.int64() as Long);
          break;
        case 2:
          message.type = reader.string();
          break;
        case 3:
          message.url = reader.string();
          break;
        case 4:
          message.config = Struct.unwrap(
            Struct.decode(reader, reader.uint32())
          );
          break;
        case 5:
          message.events.push(reader.string());
          break;
        case 6:
          message.hook_desc = HookEvent.decode(reader, reader.uint32());
          break;
        case 7:
          message.active = reader.bool();
          break;
        case 8:
          message.updated_at = longToNumber(reader.int64() as Long);
          break;
        case 10:
          message.created_at = longToNumber(reader.int64() as Long);
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): Hook {
    return {
      id: isSet(object.id) ? Number(object.id) : 0,
      type: isSet(object.type) ? String(object.type) : "",
      url: isSet(object.url) ? String(object.url) : "",
      config: isObject(object.config) ? object.config : undefined,
      events: Array.isArray(object?.events)
        ? object.events.map((e: any) => String(e))
        : [],
      hook_desc: isSet(object.hook_desc)
        ? HookEvent.fromJSON(object.hook_desc)
        : undefined,
      active: isSet(object.active) ? Boolean(object.active) : false,
      updated_at: isSet(object.updated_at) ? Number(object.updated_at) : 0,
      created_at: isSet(object.created_at) ? Number(object.created_at) : 0,
    };
  },

  toJSON(message: Hook): unknown {
    const obj: any = {};
    message.id !== undefined && (obj.id = Math.round(message.id));
    message.type !== undefined && (obj.type = message.type);
    message.url !== undefined && (obj.url = message.url);
    message.config !== undefined && (obj.config = message.config);
    if (message.events) {
      obj.events = message.events.map((e) => e);
    } else {
      obj.events = [];
    }
    message.hook_desc !== undefined &&
      (obj.hook_desc = message.hook_desc
        ? HookEvent.toJSON(message.hook_desc)
        : undefined);
    message.active !== undefined && (obj.active = message.active);
    message.updated_at !== undefined &&
      (obj.updated_at = Math.round(message.updated_at));
    message.created_at !== undefined &&
      (obj.created_at = Math.round(message.created_at));
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<Hook>, I>>(object: I): Hook {
    const message = createBaseHook();
    message.id = object.id ?? 0;
    message.type = object.type ?? "";
    message.url = object.url ?? "";
    message.config = object.config ?? undefined;
    message.events = object.events?.map((e) => e) || [];
    message.hook_desc =
      object.hook_desc !== undefined && object.hook_desc !== null
        ? HookEvent.fromPartial(object.hook_desc)
        : undefined;
    message.active = object.active ?? false;
    message.updated_at = object.updated_at ?? 0;
    message.created_at = object.created_at ?? 0;
    return message;
  },
};

function createBaseHookEvent(): HookEvent {
  return { push_only: false, send_everything: false, choose_events: false };
}

export const HookEvent = {
  encode(
    message: HookEvent,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.push_only === true) {
      writer.uint32(8).bool(message.push_only);
    }
    if (message.send_everything === true) {
      writer.uint32(16).bool(message.send_everything);
    }
    if (message.choose_events === true) {
      writer.uint32(24).bool(message.choose_events);
    }
    return writer;
  },

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

  fromJSON(object: any): HookEvent {
    return {
      push_only: isSet(object.push_only) ? Boolean(object.push_only) : false,
      send_everything: isSet(object.send_everything)
        ? Boolean(object.send_everything)
        : false,
      choose_events: isSet(object.choose_events)
        ? Boolean(object.choose_events)
        : false,
    };
  },

  toJSON(message: HookEvent): unknown {
    const obj: any = {};
    message.push_only !== undefined && (obj.push_only = message.push_only);
    message.send_everything !== undefined &&
      (obj.send_everything = message.send_everything);
    message.choose_events !== undefined &&
      (obj.choose_events = message.choose_events);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<HookEvent>, I>>(
    object: I
  ): HookEvent {
    const message = createBaseHookEvent();
    message.push_only = object.push_only ?? false;
    message.send_everything = object.send_everything ?? false;
    message.choose_events = object.choose_events ?? false;
    return message;
  },
};

function createBaseHookOption(): HookOption {
  return {
    id: 0,
    type: "",
    events: [],
    event_type: "",
    active: false,
    config: undefined,
  };
}

export const HookOption = {
  encode(
    message: HookOption,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.id !== 0) {
      writer.uint32(8).int64(message.id);
    }
    if (message.type !== "") {
      writer.uint32(18).string(message.type);
    }
    for (const v of message.events) {
      writer.uint32(26).string(v!);
    }
    if (message.event_type !== "") {
      writer.uint32(34).string(message.event_type);
    }
    if (message.active === true) {
      writer.uint32(40).bool(message.active);
    }
    if (message.config !== undefined) {
      Struct.encode(
        Struct.wrap(message.config),
        writer.uint32(50).fork()
      ).ldelim();
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): HookOption {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseHookOption();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.id = longToNumber(reader.int64() as Long);
          break;
        case 2:
          message.type = reader.string();
          break;
        case 3:
          message.events.push(reader.string());
          break;
        case 4:
          message.event_type = reader.string();
          break;
        case 5:
          message.active = reader.bool();
          break;
        case 6:
          message.config = Struct.unwrap(
            Struct.decode(reader, reader.uint32())
          );
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): HookOption {
    return {
      id: isSet(object.id) ? Number(object.id) : 0,
      type: isSet(object.type) ? String(object.type) : "",
      events: Array.isArray(object?.events)
        ? object.events.map((e: any) => String(e))
        : [],
      event_type: isSet(object.event_type) ? String(object.event_type) : "",
      active: isSet(object.active) ? Boolean(object.active) : false,
      config: isObject(object.config) ? object.config : undefined,
    };
  },

  toJSON(message: HookOption): unknown {
    const obj: any = {};
    message.id !== undefined && (obj.id = Math.round(message.id));
    message.type !== undefined && (obj.type = message.type);
    if (message.events) {
      obj.events = message.events.map((e) => e);
    } else {
      obj.events = [];
    }
    message.event_type !== undefined && (obj.event_type = message.event_type);
    message.active !== undefined && (obj.active = message.active);
    message.config !== undefined && (obj.config = message.config);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<HookOption>, I>>(
    object: I
  ): HookOption {
    const message = createBaseHookOption();
    message.id = object.id ?? 0;
    message.type = object.type ?? "";
    message.events = object.events?.map((e) => e) || [];
    message.event_type = object.event_type ?? "";
    message.active = object.active ?? false;
    message.config = object.config ?? undefined;
    return message;
  },
};

function createBaseDeleteHookRequest(): DeleteHookRequest {
  return { id: 0 };
}

export const DeleteHookRequest = {
  encode(
    message: DeleteHookRequest,
    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): DeleteHookRequest {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseDeleteHookRequest();
    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): DeleteHookRequest {
    return {
      id: isSet(object.id) ? Number(object.id) : 0,
    };
  },

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

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

export interface Org {
  GetOrgBindApp(
    request: DeepPartial<GetOrgBindAppRequest>,
    metadata?: grpc.Metadata
  ): Promise<GetOrgBindAppResponse>;
  GetOrgMemberTeams(
    request: DeepPartial<GetOrgMemberTeamsRequest>,
    metadata?: grpc.Metadata
  ): Promise<GetOrgMemberTeamsResponse>;
  GetOrgMembers(
    request: DeepPartial<GetOrgMembersRequest>,
    metadata?: grpc.Metadata
  ): Promise<GetOrgMembersResponse>;
  LeaveOrg(
    request: DeepPartial<Empty>,
    metadata?: grpc.Metadata
  ): Promise<Empty>;
  RemoveOrgMembers(
    request: DeepPartial<RemoveOrgMembersRequest>,
    metadata?: grpc.Metadata
  ): Promise<Empty>;
  Online(
    request: DeepPartial<Empty>,
    metadata?: grpc.Metadata
  ): Promise<OnlineResponse>;
  GetHooks(
    request: DeepPartial<Empty>,
    metadata?: grpc.Metadata
  ): Promise<GetHooksResponse>;
  CreateHook(
    request: DeepPartial<HookOption>,
    metadata?: grpc.Metadata
  ): Promise<Empty>;
  EditHook(
    request: DeepPartial<HookOption>,
    metadata?: grpc.Metadata
  ): Promise<Empty>;
  DeleteHook(
    request: DeepPartial<DeleteHookRequest>,
    metadata?: grpc.Metadata
  ): Promise<Empty>;
}

export class OrgClientImpl implements Org {
  private readonly rpc: Rpc;

  constructor(rpc: Rpc) {
    this.rpc = rpc;
    this.GetOrgBindApp = this.GetOrgBindApp.bind(this);
    this.GetOrgMemberTeams = this.GetOrgMemberTeams.bind(this);
    this.GetOrgMembers = this.GetOrgMembers.bind(this);
    this.LeaveOrg = this.LeaveOrg.bind(this);
    this.RemoveOrgMembers = this.RemoveOrgMembers.bind(this);
    this.Online = this.Online.bind(this);
    this.GetHooks = this.GetHooks.bind(this);
    this.CreateHook = this.CreateHook.bind(this);
    this.EditHook = this.EditHook.bind(this);
    this.DeleteHook = this.DeleteHook.bind(this);
  }

  GetOrgBindApp(
    request: DeepPartial<GetOrgBindAppRequest>,
    metadata?: grpc.Metadata
  ): Promise<GetOrgBindAppResponse> {
    return this.rpc.unary(
      OrgGetOrgBindAppDesc,
      GetOrgBindAppRequest.fromPartial(request),
      metadata
    );
  }

  GetOrgMemberTeams(
    request: DeepPartial<GetOrgMemberTeamsRequest>,
    metadata?: grpc.Metadata
  ): Promise<GetOrgMemberTeamsResponse> {
    return this.rpc.unary(
      OrgGetOrgMemberTeamsDesc,
      GetOrgMemberTeamsRequest.fromPartial(request),
      metadata
    );
  }

  GetOrgMembers(
    request: DeepPartial<GetOrgMembersRequest>,
    metadata?: grpc.Metadata
  ): Promise<GetOrgMembersResponse> {
    return this.rpc.unary(
      OrgGetOrgMembersDesc,
      GetOrgMembersRequest.fromPartial(request),
      metadata
    );
  }

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

  RemoveOrgMembers(
    request: DeepPartial<RemoveOrgMembersRequest>,
    metadata?: grpc.Metadata
  ): Promise<Empty> {
    return this.rpc.unary(
      OrgRemoveOrgMembersDesc,
      RemoveOrgMembersRequest.fromPartial(request),
      metadata
    );
  }

  Online(
    request: DeepPartial<Empty>,
    metadata?: grpc.Metadata
  ): Promise<OnlineResponse> {
    return this.rpc.unary(OrgOnlineDesc, Empty.fromPartial(request), metadata);
  }

  GetHooks(
    request: DeepPartial<Empty>,
    metadata?: grpc.Metadata
  ): Promise<GetHooksResponse> {
    return this.rpc.unary(
      OrgGetHooksDesc,
      Empty.fromPartial(request),
      metadata
    );
  }

  CreateHook(
    request: DeepPartial<HookOption>,
    metadata?: grpc.Metadata
  ): Promise<Empty> {
    return this.rpc.unary(
      OrgCreateHookDesc,
      HookOption.fromPartial(request),
      metadata
    );
  }

  EditHook(
    request: DeepPartial<HookOption>,
    metadata?: grpc.Metadata
  ): Promise<Empty> {
    return this.rpc.unary(
      OrgEditHookDesc,
      HookOption.fromPartial(request),
      metadata
    );
  }

  DeleteHook(
    request: DeepPartial<DeleteHookRequest>,
    metadata?: grpc.Metadata
  ): Promise<Empty> {
    return this.rpc.unary(
      OrgDeleteHookDesc,
      DeleteHookRequest.fromPartial(request),
      metadata
    );
  }
}

export const OrgDesc = {
  serviceName: "api.v1.Org",
};

export const OrgGetOrgBindAppDesc: UnaryMethodDefinitionish = {
  methodName: "GetOrgBindApp",
  service: OrgDesc,
  requestStream: false,
  responseStream: false,
  requestType: {
    serializeBinary() {
      return GetOrgBindAppRequest.encode(this).finish();
    },
  } as any,
  responseType: {
    deserializeBinary(data: Uint8Array) {
      return {
        ...GetOrgBindAppResponse.decode(data),
        toObject() {
          return this;
        },
      };
    },
  } as any,
};

export const OrgGetOrgMemberTeamsDesc: UnaryMethodDefinitionish = {
  methodName: "GetOrgMemberTeams",
  service: OrgDesc,
  requestStream: false,
  responseStream: false,
  requestType: {
    serializeBinary() {
      return GetOrgMemberTeamsRequest.encode(this).finish();
    },
  } as any,
  responseType: {
    deserializeBinary(data: Uint8Array) {
      return {
        ...GetOrgMemberTeamsResponse.decode(data),
        toObject() {
          return this;
        },
      };
    },
  } as any,
};

export const OrgGetOrgMembersDesc: UnaryMethodDefinitionish = {
  methodName: "GetOrgMembers",
  service: OrgDesc,
  requestStream: false,
  responseStream: false,
  requestType: {
    serializeBinary() {
      return GetOrgMembersRequest.encode(this).finish();
    },
  } as any,
  responseType: {
    deserializeBinary(data: Uint8Array) {
      return {
        ...GetOrgMembersResponse.decode(data),
        toObject() {
          return this;
        },
      };
    },
  } as any,
};

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

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

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

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

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

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

export const OrgDeleteHookDesc: UnaryMethodDefinitionish = {
  methodName: "DeleteHook",
  service: OrgDesc,
  requestStream: false,
  responseStream: false,
  requestType: {
    serializeBinary() {
      return DeleteHookRequest.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 isObject(value: any): boolean {
  return typeof value === "object" && value !== null;
}

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