/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
import {
  IError,
  QueryFilterRequest,
  RemoveReply,
  Timestamp,
} from "../../core/common";
import {
  RoleEntity,
  UserEntity,
  UserRoleWorkspace,
  WorkspaceEntity,
} from "../workspaces/index";

export const protobufPackage = "";

export interface CreateByMailResponse {
  error: IError | undefined;
  data: UserSessionDto | undefined;
}

export interface EmailAccountSignupDto {
  /** @tag(validate:"required") */
  email: string;
  /** @tag(validate:"required") */
  password: string;
  /** @tag(validate:"required") */
  firstName: string;
  /** @tag(validate:"required") */
  lastName: string;
  inviteId: string;
  publicJoinKeyId: string;
  workspaceTypeId: string;
}

export interface EmailAccountSigninDto {
  /** @tag(validate:"required") */
  email: string;
  /** @tag(validate:"required") */
  password: string;
}

export interface PhoneNumberAccountCreationDto {
  /** @tag(validate:"required") */
  phoneNumber: string;
}

export interface PhoneNumberUniversalAuthenticateDto {
  /** @tag(validate:"required") */
  phoneNumber: string;
}

export interface ForgetPasswordEntity {
  /** @tag(gorm:"foreignKey:UserId;references:UniqueId" json:"-") */
  user: UserEntity | undefined;
  /** @tag(json:"-") */
  userId?: string | undefined;
  /** @tag(gorm:"foreignKey:PassportId;references:UniqueId" json:"-") */
  passport: PassportEntity | undefined;
  /** @tag(json:"passportId" json:"-") */
  passportId?: string | undefined;
  /** @tag(json:"-") */
  status: string;
  /** @tag(gorm:"primarykey;uniqueId;unique;not null;size:100;" json:"-") */
  uniqueId: string;
  validUntil: Timestamp | undefined;
  blockedUntil: Timestamp | undefined;
  secondsToUnblock: number;
  /** @tag(json:"-") */
  otp: string;
  /** @tag(json:"-" gorm:"-" sql:"-") */
  recoveryAbsoluteUrl: string;
  /** @tag(gorm:"autoUpdateTime:nano") */
  updated: number;
  /** @tag(gorm:"autoUpdateTime:nano") */
  created: number;
}

export interface EmailConfirmationEntity {
  /** @tag(gorm:"primarykey;uniqueId;unique;not null;size:100;") */
  uniqueId: string;
  /** @tag(gorm:"foreignKey:UserId;references:UniqueId" json:"-") */
  user: UserEntity | undefined;
  userId?: string | undefined;
  status: string;
  expiresAt: string;
  /** @tag(gorm:"autoUpdateTime:nano") */
  updated: number;
  /** @tag(gorm:"autoUpdateTime:nano") */
  created: number;
}

export interface PhoneConfirmationEntity {
  /** @tag(gorm:"primarykey;uniqueId;unique;not null;size:100;") */
  uniqueId: string;
  /** @tag(gorm:"foreignKey:UserId;references:UniqueId" json:"-") */
  user: UserEntity | undefined;
  userId?: string | undefined;
  status: string;
  phoneNumber: string;
  key: string;
  expiresAt: string;
  /** @tag(gorm:"autoUpdateTime:nano") */
  updated: number;
  /** @tag(gorm:"autoUpdateTime:nano") */
  created: number;
}

export interface PassportEntity {
  /** @tag(json:"type" validate:"required") */
  type: string;
  /** @tag(json:"value" gorm:"unique" validate:"required") */
  value: string;
  /** @tag(json:"-") */
  password: string;
  /** @tag(json:"confirmed") */
  confirmed: boolean;
  /** @tag(json:"accessToken") */
  accessToken: string;
  /** @tag(json:"userId" validate:"required") */
  userId: string;
  /** @tag(json:"uniqueId" gorm:"primarykey;uniqueId;unique;not null;size:100;") */
  uniqueId: string;
  /** @tag(gorm:"autoUpdateTime:nano") */
  updated: number;
  /** @tag(gorm:"autoUpdateTime:nano") */
  created: number;
}

export interface UserSessionDto {
  passport: PassportEntity | undefined;
  token: string;
  exchangeKey: string;
  /** @tag(json:"userRoleWorkspaces") */
  userRoleWorkspaces: UserRoleWorkspace[];
  user: UserEntity | undefined;
}

export interface PublicJoinKey {
  /** @tag(gorm:"foreignKey:WorkspaceId;references:UniqueId" json:"-") */
  workspace: WorkspaceEntity | undefined;
  /** @tag(json:"workspaceId" gorm:"size:100;") */
  workspaceId?: string | undefined;
  /** @tag(gorm:"foreignKey:RoleId;references:UniqueId") */
  role: RoleEntity | undefined;
  /** @tag(gorm:"size:100;") */
  roleId?: string | undefined;
  /** @tag(gorm:"primarykey;uniqueId;unique;not null;size:100;" yaml:"uniqueId") */
  uniqueId: string;
  /** @tag(yaml:"visibility") */
  visibility?: string | undefined;
  /** @tag(gorm:"autoUpdateTime:nano") */
  updated: number;
  /** @tag(gorm:"autoUpdateTime:nano") */
  created: number;
}

export interface OtpAuthenticateDto {
  /** @tag(validate:"required") */
  value: string;
  otp: string;
  /** @tag(validate:"required") */
  type: string;
  password: string;
}

export interface EmailOtpResponse {
  request: ForgetPasswordEntity | undefined;
  userSession: UserSessionDto | undefined;
}

export interface ResetEmailDto {
  password: string;
}

export interface PassportMethodCreateReply {
  data: PassportMethodEntity | undefined;
  error: IError | undefined;
}

export interface PassportMethodReply {
  data: PassportMethodEntity | undefined;
  error: IError | undefined;
}

export interface PassportMethodQueryReply {
  items: PassportMethodEntity[];
  totalItems: number;
  itemsPerPage: number;
  startIndex: number;
  error: IError | undefined;
}

export interface PassportMethodEntity {
  /** @tag(yaml:"visibility") */
  visibility?: string | undefined;
  /** @tag(yaml:"workspaceId") */
  workspaceId?: string | undefined;
  /** @tag(yaml:"linkerId") */
  linkerId?: string | undefined;
  /** @tag(yaml:"parentId") */
  parentId?: string | undefined;
  /** @tag(gorm:"primarykey;uniqueId;unique;not null;size:100;" yaml:"uniqueId") */
  uniqueId: string;
  /** @tag(yaml:"userId") */
  userId?: string | undefined;
  /** @tag(gorm:"foreignKey:LinkerId;references:UniqueId" json:"translations") */
  translations: PassportMethodEntityPolyglot[];
  /** @tag(translate:"true" validate:"required" yaml:"name"  ) */
  name?: string | undefined;
  /** @tag( validate:"required" yaml:"type"  ) */
  type?: string | undefined;
  /** @tag( validate:"required" yaml:"region"  ) */
  region?: string | undefined;
  /** @tag(gorm:"type:int;name:rank") */
  rank: number;
  /** @tag(gorm:"autoUpdateTime:nano") */
  updated: number;
  /** @tag(gorm:"autoUpdateTime:nano") */
  created: number;
  /** @tag(sql:"-") */
  createdFormatted: string;
  /** @tag(sql:"-") */
  updatedFormatted: string;
}

/** Because it has translation field, we need a translation table for this */
export interface PassportMethodEntityPolyglot {
  /** @tag(gorm:"uniqueId;not null;size:100;" json:"linkerId" yaml:"linkerId") */
  linkerId: string;
  /** @tag(gorm:"uniqueId;not null;size:100;" json:"languageId" yaml:"languageId") */
  languageId: string;
  /** @tag(yaml:"name" json:"name"); */
  name: string;
}

function createBaseCreateByMailResponse(): CreateByMailResponse {
  return { error: undefined, data: undefined };
}

export const CreateByMailResponse = {
  encode(
    message: CreateByMailResponse,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.error !== undefined) {
      IError.encode(message.error, writer.uint32(10).fork()).ldelim();
    }
    if (message.data !== undefined) {
      UserSessionDto.encode(message.data, writer.uint32(18).fork()).ldelim();
    }
    return writer;
  },

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

  fromJSON(object: any): CreateByMailResponse {
    return {
      error: isSet(object.error) ? IError.fromJSON(object.error) : undefined,
      data: isSet(object.data)
        ? UserSessionDto.fromJSON(object.data)
        : undefined,
    };
  },

  toJSON(message: CreateByMailResponse): unknown {
    const obj: any = {};
    message.error !== undefined &&
      (obj.error = message.error ? IError.toJSON(message.error) : undefined);
    message.data !== undefined &&
      (obj.data = message.data
        ? UserSessionDto.toJSON(message.data)
        : undefined);
    return obj;
  },

  create<I extends Exact<DeepPartial<CreateByMailResponse>, I>>(
    base?: I
  ): CreateByMailResponse {
    return CreateByMailResponse.fromPartial(base ?? {});
  },

  fromPartial<I extends Exact<DeepPartial<CreateByMailResponse>, I>>(
    object: I
  ): CreateByMailResponse {
    const message = createBaseCreateByMailResponse();
    message.error =
      object.error !== undefined && object.error !== null
        ? IError.fromPartial(object.error)
        : undefined;
    message.data =
      object.data !== undefined && object.data !== null
        ? UserSessionDto.fromPartial(object.data)
        : undefined;
    return message;
  },
};

function createBaseEmailAccountSignupDto(): EmailAccountSignupDto {
  return {
    email: "",
    password: "",
    firstName: "",
    lastName: "",
    inviteId: "",
    publicJoinKeyId: "",
    workspaceTypeId: "",
  };
}

export const EmailAccountSignupDto = {
  encode(
    message: EmailAccountSignupDto,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.email !== "") {
      writer.uint32(10).string(message.email);
    }
    if (message.password !== "") {
      writer.uint32(18).string(message.password);
    }
    if (message.firstName !== "") {
      writer.uint32(26).string(message.firstName);
    }
    if (message.lastName !== "") {
      writer.uint32(34).string(message.lastName);
    }
    if (message.inviteId !== "") {
      writer.uint32(42).string(message.inviteId);
    }
    if (message.publicJoinKeyId !== "") {
      writer.uint32(50).string(message.publicJoinKeyId);
    }
    if (message.workspaceTypeId !== "") {
      writer.uint32(58).string(message.workspaceTypeId);
    }
    return writer;
  },

  decode(
    input: _m0.Reader | Uint8Array,
    length?: number
  ): EmailAccountSignupDto {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseEmailAccountSignupDto();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.email = reader.string();
          break;
        case 2:
          message.password = reader.string();
          break;
        case 3:
          message.firstName = reader.string();
          break;
        case 4:
          message.lastName = reader.string();
          break;
        case 5:
          message.inviteId = reader.string();
          break;
        case 6:
          message.publicJoinKeyId = reader.string();
          break;
        case 7:
          message.workspaceTypeId = reader.string();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): EmailAccountSignupDto {
    return {
      email: isSet(object.email) ? String(object.email) : "",
      password: isSet(object.password) ? String(object.password) : "",
      firstName: isSet(object.firstName) ? String(object.firstName) : "",
      lastName: isSet(object.lastName) ? String(object.lastName) : "",
      inviteId: isSet(object.inviteId) ? String(object.inviteId) : "",
      publicJoinKeyId: isSet(object.publicJoinKeyId)
        ? String(object.publicJoinKeyId)
        : "",
      workspaceTypeId: isSet(object.workspaceTypeId)
        ? String(object.workspaceTypeId)
        : "",
    };
  },

  toJSON(message: EmailAccountSignupDto): unknown {
    const obj: any = {};
    message.email !== undefined && (obj.email = message.email);
    message.password !== undefined && (obj.password = message.password);
    message.firstName !== undefined && (obj.firstName = message.firstName);
    message.lastName !== undefined && (obj.lastName = message.lastName);
    message.inviteId !== undefined && (obj.inviteId = message.inviteId);
    message.publicJoinKeyId !== undefined &&
      (obj.publicJoinKeyId = message.publicJoinKeyId);
    message.workspaceTypeId !== undefined &&
      (obj.workspaceTypeId = message.workspaceTypeId);
    return obj;
  },

  create<I extends Exact<DeepPartial<EmailAccountSignupDto>, I>>(
    base?: I
  ): EmailAccountSignupDto {
    return EmailAccountSignupDto.fromPartial(base ?? {});
  },

  fromPartial<I extends Exact<DeepPartial<EmailAccountSignupDto>, I>>(
    object: I
  ): EmailAccountSignupDto {
    const message = createBaseEmailAccountSignupDto();
    message.email = object.email ?? "";
    message.password = object.password ?? "";
    message.firstName = object.firstName ?? "";
    message.lastName = object.lastName ?? "";
    message.inviteId = object.inviteId ?? "";
    message.publicJoinKeyId = object.publicJoinKeyId ?? "";
    message.workspaceTypeId = object.workspaceTypeId ?? "";
    return message;
  },
};

function createBaseEmailAccountSigninDto(): EmailAccountSigninDto {
  return { email: "", password: "" };
}

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

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

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

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

  create<I extends Exact<DeepPartial<EmailAccountSigninDto>, I>>(
    base?: I
  ): EmailAccountSigninDto {
    return EmailAccountSigninDto.fromPartial(base ?? {});
  },

  fromPartial<I extends Exact<DeepPartial<EmailAccountSigninDto>, I>>(
    object: I
  ): EmailAccountSigninDto {
    const message = createBaseEmailAccountSigninDto();
    message.email = object.email ?? "";
    message.password = object.password ?? "";
    return message;
  },
};

function createBasePhoneNumberAccountCreationDto(): PhoneNumberAccountCreationDto {
  return { phoneNumber: "" };
}

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

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

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

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

  create<I extends Exact<DeepPartial<PhoneNumberAccountCreationDto>, I>>(
    base?: I
  ): PhoneNumberAccountCreationDto {
    return PhoneNumberAccountCreationDto.fromPartial(base ?? {});
  },

  fromPartial<I extends Exact<DeepPartial<PhoneNumberAccountCreationDto>, I>>(
    object: I
  ): PhoneNumberAccountCreationDto {
    const message = createBasePhoneNumberAccountCreationDto();
    message.phoneNumber = object.phoneNumber ?? "";
    return message;
  },
};

function createBasePhoneNumberUniversalAuthenticateDto(): PhoneNumberUniversalAuthenticateDto {
  return { phoneNumber: "" };
}

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

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

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

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

  create<I extends Exact<DeepPartial<PhoneNumberUniversalAuthenticateDto>, I>>(
    base?: I
  ): PhoneNumberUniversalAuthenticateDto {
    return PhoneNumberUniversalAuthenticateDto.fromPartial(base ?? {});
  },

  fromPartial<
    I extends Exact<DeepPartial<PhoneNumberUniversalAuthenticateDto>, I>
  >(object: I): PhoneNumberUniversalAuthenticateDto {
    const message = createBasePhoneNumberUniversalAuthenticateDto();
    message.phoneNumber = object.phoneNumber ?? "";
    return message;
  },
};

function createBaseForgetPasswordEntity(): ForgetPasswordEntity {
  return {
    user: undefined,
    userId: undefined,
    passport: undefined,
    passportId: undefined,
    status: "",
    uniqueId: "",
    validUntil: undefined,
    blockedUntil: undefined,
    secondsToUnblock: 0,
    otp: "",
    recoveryAbsoluteUrl: "",
    updated: 0,
    created: 0,
  };
}

export const ForgetPasswordEntity = {
  encode(
    message: ForgetPasswordEntity,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.user !== undefined) {
      UserEntity.encode(message.user, writer.uint32(10).fork()).ldelim();
    }
    if (message.userId !== undefined) {
      writer.uint32(18).string(message.userId);
    }
    if (message.passport !== undefined) {
      PassportEntity.encode(
        message.passport,
        writer.uint32(26).fork()
      ).ldelim();
    }
    if (message.passportId !== undefined) {
      writer.uint32(34).string(message.passportId);
    }
    if (message.status !== "") {
      writer.uint32(42).string(message.status);
    }
    if (message.uniqueId !== "") {
      writer.uint32(50).string(message.uniqueId);
    }
    if (message.validUntil !== undefined) {
      Timestamp.encode(message.validUntil, writer.uint32(66).fork()).ldelim();
    }
    if (message.blockedUntil !== undefined) {
      Timestamp.encode(message.blockedUntil, writer.uint32(74).fork()).ldelim();
    }
    if (message.secondsToUnblock !== 0) {
      writer.uint32(80).int64(message.secondsToUnblock);
    }
    if (message.otp !== "") {
      writer.uint32(90).string(message.otp);
    }
    if (message.recoveryAbsoluteUrl !== "") {
      writer.uint32(98).string(message.recoveryAbsoluteUrl);
    }
    if (message.updated !== 0) {
      writer.uint32(128).int64(message.updated);
    }
    if (message.created !== 0) {
      writer.uint32(136).int64(message.created);
    }
    return writer;
  },

  decode(
    input: _m0.Reader | Uint8Array,
    length?: number
  ): ForgetPasswordEntity {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseForgetPasswordEntity();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.user = UserEntity.decode(reader, reader.uint32());
          break;
        case 2:
          message.userId = reader.string();
          break;
        case 3:
          message.passport = PassportEntity.decode(reader, reader.uint32());
          break;
        case 4:
          message.passportId = reader.string();
          break;
        case 5:
          message.status = reader.string();
          break;
        case 6:
          message.uniqueId = reader.string();
          break;
        case 8:
          message.validUntil = Timestamp.decode(reader, reader.uint32());
          break;
        case 9:
          message.blockedUntil = Timestamp.decode(reader, reader.uint32());
          break;
        case 10:
          message.secondsToUnblock = longToNumber(reader.int64() as Long);
          break;
        case 11:
          message.otp = reader.string();
          break;
        case 12:
          message.recoveryAbsoluteUrl = reader.string();
          break;
        case 16:
          message.updated = longToNumber(reader.int64() as Long);
          break;
        case 17:
          message.created = longToNumber(reader.int64() as Long);
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): ForgetPasswordEntity {
    return {
      user: isSet(object.user) ? UserEntity.fromJSON(object.user) : undefined,
      userId: isSet(object.userId) ? String(object.userId) : undefined,
      passport: isSet(object.passport)
        ? PassportEntity.fromJSON(object.passport)
        : undefined,
      passportId: isSet(object.passportId)
        ? String(object.passportId)
        : undefined,
      status: isSet(object.status) ? String(object.status) : "",
      uniqueId: isSet(object.uniqueId) ? String(object.uniqueId) : "",
      validUntil: isSet(object.validUntil)
        ? Timestamp.fromJSON(object.validUntil)
        : undefined,
      blockedUntil: isSet(object.blockedUntil)
        ? Timestamp.fromJSON(object.blockedUntil)
        : undefined,
      secondsToUnblock: isSet(object.secondsToUnblock)
        ? Number(object.secondsToUnblock)
        : 0,
      otp: isSet(object.otp) ? String(object.otp) : "",
      recoveryAbsoluteUrl: isSet(object.recoveryAbsoluteUrl)
        ? String(object.recoveryAbsoluteUrl)
        : "",
      updated: isSet(object.updated) ? Number(object.updated) : 0,
      created: isSet(object.created) ? Number(object.created) : 0,
    };
  },

  toJSON(message: ForgetPasswordEntity): unknown {
    const obj: any = {};
    message.user !== undefined &&
      (obj.user = message.user ? UserEntity.toJSON(message.user) : undefined);
    message.userId !== undefined && (obj.userId = message.userId);
    message.passport !== undefined &&
      (obj.passport = message.passport
        ? PassportEntity.toJSON(message.passport)
        : undefined);
    message.passportId !== undefined && (obj.passportId = message.passportId);
    message.status !== undefined && (obj.status = message.status);
    message.uniqueId !== undefined && (obj.uniqueId = message.uniqueId);
    message.validUntil !== undefined &&
      (obj.validUntil = message.validUntil
        ? Timestamp.toJSON(message.validUntil)
        : undefined);
    message.blockedUntil !== undefined &&
      (obj.blockedUntil = message.blockedUntil
        ? Timestamp.toJSON(message.blockedUntil)
        : undefined);
    message.secondsToUnblock !== undefined &&
      (obj.secondsToUnblock = Math.round(message.secondsToUnblock));
    message.otp !== undefined && (obj.otp = message.otp);
    message.recoveryAbsoluteUrl !== undefined &&
      (obj.recoveryAbsoluteUrl = message.recoveryAbsoluteUrl);
    message.updated !== undefined &&
      (obj.updated = Math.round(message.updated));
    message.created !== undefined &&
      (obj.created = Math.round(message.created));
    return obj;
  },

  create<I extends Exact<DeepPartial<ForgetPasswordEntity>, I>>(
    base?: I
  ): ForgetPasswordEntity {
    return ForgetPasswordEntity.fromPartial(base ?? {});
  },

  fromPartial<I extends Exact<DeepPartial<ForgetPasswordEntity>, I>>(
    object: I
  ): ForgetPasswordEntity {
    const message = createBaseForgetPasswordEntity();
    message.user =
      object.user !== undefined && object.user !== null
        ? UserEntity.fromPartial(object.user)
        : undefined;
    message.userId = object.userId ?? undefined;
    message.passport =
      object.passport !== undefined && object.passport !== null
        ? PassportEntity.fromPartial(object.passport)
        : undefined;
    message.passportId = object.passportId ?? undefined;
    message.status = object.status ?? "";
    message.uniqueId = object.uniqueId ?? "";
    message.validUntil =
      object.validUntil !== undefined && object.validUntil !== null
        ? Timestamp.fromPartial(object.validUntil)
        : undefined;
    message.blockedUntil =
      object.blockedUntil !== undefined && object.blockedUntil !== null
        ? Timestamp.fromPartial(object.blockedUntil)
        : undefined;
    message.secondsToUnblock = object.secondsToUnblock ?? 0;
    message.otp = object.otp ?? "";
    message.recoveryAbsoluteUrl = object.recoveryAbsoluteUrl ?? "";
    message.updated = object.updated ?? 0;
    message.created = object.created ?? 0;
    return message;
  },
};

function createBaseEmailConfirmationEntity(): EmailConfirmationEntity {
  return {
    uniqueId: "",
    user: undefined,
    userId: undefined,
    status: "",
    expiresAt: "",
    updated: 0,
    created: 0,
  };
}

export const EmailConfirmationEntity = {
  encode(
    message: EmailConfirmationEntity,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.uniqueId !== "") {
      writer.uint32(10).string(message.uniqueId);
    }
    if (message.user !== undefined) {
      UserEntity.encode(message.user, writer.uint32(18).fork()).ldelim();
    }
    if (message.userId !== undefined) {
      writer.uint32(26).string(message.userId);
    }
    if (message.status !== "") {
      writer.uint32(34).string(message.status);
    }
    if (message.expiresAt !== "") {
      writer.uint32(42).string(message.expiresAt);
    }
    if (message.updated !== 0) {
      writer.uint32(128).int64(message.updated);
    }
    if (message.created !== 0) {
      writer.uint32(136).int64(message.created);
    }
    return writer;
  },

  decode(
    input: _m0.Reader | Uint8Array,
    length?: number
  ): EmailConfirmationEntity {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseEmailConfirmationEntity();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.uniqueId = reader.string();
          break;
        case 2:
          message.user = UserEntity.decode(reader, reader.uint32());
          break;
        case 3:
          message.userId = reader.string();
          break;
        case 4:
          message.status = reader.string();
          break;
        case 5:
          message.expiresAt = reader.string();
          break;
        case 16:
          message.updated = longToNumber(reader.int64() as Long);
          break;
        case 17:
          message.created = longToNumber(reader.int64() as Long);
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): EmailConfirmationEntity {
    return {
      uniqueId: isSet(object.uniqueId) ? String(object.uniqueId) : "",
      user: isSet(object.user) ? UserEntity.fromJSON(object.user) : undefined,
      userId: isSet(object.userId) ? String(object.userId) : undefined,
      status: isSet(object.status) ? String(object.status) : "",
      expiresAt: isSet(object.expiresAt) ? String(object.expiresAt) : "",
      updated: isSet(object.updated) ? Number(object.updated) : 0,
      created: isSet(object.created) ? Number(object.created) : 0,
    };
  },

  toJSON(message: EmailConfirmationEntity): unknown {
    const obj: any = {};
    message.uniqueId !== undefined && (obj.uniqueId = message.uniqueId);
    message.user !== undefined &&
      (obj.user = message.user ? UserEntity.toJSON(message.user) : undefined);
    message.userId !== undefined && (obj.userId = message.userId);
    message.status !== undefined && (obj.status = message.status);
    message.expiresAt !== undefined && (obj.expiresAt = message.expiresAt);
    message.updated !== undefined &&
      (obj.updated = Math.round(message.updated));
    message.created !== undefined &&
      (obj.created = Math.round(message.created));
    return obj;
  },

  create<I extends Exact<DeepPartial<EmailConfirmationEntity>, I>>(
    base?: I
  ): EmailConfirmationEntity {
    return EmailConfirmationEntity.fromPartial(base ?? {});
  },

  fromPartial<I extends Exact<DeepPartial<EmailConfirmationEntity>, I>>(
    object: I
  ): EmailConfirmationEntity {
    const message = createBaseEmailConfirmationEntity();
    message.uniqueId = object.uniqueId ?? "";
    message.user =
      object.user !== undefined && object.user !== null
        ? UserEntity.fromPartial(object.user)
        : undefined;
    message.userId = object.userId ?? undefined;
    message.status = object.status ?? "";
    message.expiresAt = object.expiresAt ?? "";
    message.updated = object.updated ?? 0;
    message.created = object.created ?? 0;
    return message;
  },
};

function createBasePhoneConfirmationEntity(): PhoneConfirmationEntity {
  return {
    uniqueId: "",
    user: undefined,
    userId: undefined,
    status: "",
    phoneNumber: "",
    key: "",
    expiresAt: "",
    updated: 0,
    created: 0,
  };
}

export const PhoneConfirmationEntity = {
  encode(
    message: PhoneConfirmationEntity,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.uniqueId !== "") {
      writer.uint32(10).string(message.uniqueId);
    }
    if (message.user !== undefined) {
      UserEntity.encode(message.user, writer.uint32(18).fork()).ldelim();
    }
    if (message.userId !== undefined) {
      writer.uint32(26).string(message.userId);
    }
    if (message.status !== "") {
      writer.uint32(34).string(message.status);
    }
    if (message.phoneNumber !== "") {
      writer.uint32(42).string(message.phoneNumber);
    }
    if (message.key !== "") {
      writer.uint32(50).string(message.key);
    }
    if (message.expiresAt !== "") {
      writer.uint32(58).string(message.expiresAt);
    }
    if (message.updated !== 0) {
      writer.uint32(128).int64(message.updated);
    }
    if (message.created !== 0) {
      writer.uint32(136).int64(message.created);
    }
    return writer;
  },

  decode(
    input: _m0.Reader | Uint8Array,
    length?: number
  ): PhoneConfirmationEntity {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBasePhoneConfirmationEntity();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.uniqueId = reader.string();
          break;
        case 2:
          message.user = UserEntity.decode(reader, reader.uint32());
          break;
        case 3:
          message.userId = reader.string();
          break;
        case 4:
          message.status = reader.string();
          break;
        case 5:
          message.phoneNumber = reader.string();
          break;
        case 6:
          message.key = reader.string();
          break;
        case 7:
          message.expiresAt = reader.string();
          break;
        case 16:
          message.updated = longToNumber(reader.int64() as Long);
          break;
        case 17:
          message.created = longToNumber(reader.int64() as Long);
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): PhoneConfirmationEntity {
    return {
      uniqueId: isSet(object.uniqueId) ? String(object.uniqueId) : "",
      user: isSet(object.user) ? UserEntity.fromJSON(object.user) : undefined,
      userId: isSet(object.userId) ? String(object.userId) : undefined,
      status: isSet(object.status) ? String(object.status) : "",
      phoneNumber: isSet(object.phoneNumber) ? String(object.phoneNumber) : "",
      key: isSet(object.key) ? String(object.key) : "",
      expiresAt: isSet(object.expiresAt) ? String(object.expiresAt) : "",
      updated: isSet(object.updated) ? Number(object.updated) : 0,
      created: isSet(object.created) ? Number(object.created) : 0,
    };
  },

  toJSON(message: PhoneConfirmationEntity): unknown {
    const obj: any = {};
    message.uniqueId !== undefined && (obj.uniqueId = message.uniqueId);
    message.user !== undefined &&
      (obj.user = message.user ? UserEntity.toJSON(message.user) : undefined);
    message.userId !== undefined && (obj.userId = message.userId);
    message.status !== undefined && (obj.status = message.status);
    message.phoneNumber !== undefined &&
      (obj.phoneNumber = message.phoneNumber);
    message.key !== undefined && (obj.key = message.key);
    message.expiresAt !== undefined && (obj.expiresAt = message.expiresAt);
    message.updated !== undefined &&
      (obj.updated = Math.round(message.updated));
    message.created !== undefined &&
      (obj.created = Math.round(message.created));
    return obj;
  },

  create<I extends Exact<DeepPartial<PhoneConfirmationEntity>, I>>(
    base?: I
  ): PhoneConfirmationEntity {
    return PhoneConfirmationEntity.fromPartial(base ?? {});
  },

  fromPartial<I extends Exact<DeepPartial<PhoneConfirmationEntity>, I>>(
    object: I
  ): PhoneConfirmationEntity {
    const message = createBasePhoneConfirmationEntity();
    message.uniqueId = object.uniqueId ?? "";
    message.user =
      object.user !== undefined && object.user !== null
        ? UserEntity.fromPartial(object.user)
        : undefined;
    message.userId = object.userId ?? undefined;
    message.status = object.status ?? "";
    message.phoneNumber = object.phoneNumber ?? "";
    message.key = object.key ?? "";
    message.expiresAt = object.expiresAt ?? "";
    message.updated = object.updated ?? 0;
    message.created = object.created ?? 0;
    return message;
  },
};

function createBasePassportEntity(): PassportEntity {
  return {
    type: "",
    value: "",
    password: "",
    confirmed: false,
    accessToken: "",
    userId: "",
    uniqueId: "",
    updated: 0,
    created: 0,
  };
}

export const PassportEntity = {
  encode(
    message: PassportEntity,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.type !== "") {
      writer.uint32(10).string(message.type);
    }
    if (message.value !== "") {
      writer.uint32(18).string(message.value);
    }
    if (message.password !== "") {
      writer.uint32(26).string(message.password);
    }
    if (message.confirmed === true) {
      writer.uint32(32).bool(message.confirmed);
    }
    if (message.accessToken !== "") {
      writer.uint32(42).string(message.accessToken);
    }
    if (message.userId !== "") {
      writer.uint32(50).string(message.userId);
    }
    if (message.uniqueId !== "") {
      writer.uint32(58).string(message.uniqueId);
    }
    if (message.updated !== 0) {
      writer.uint32(128).int64(message.updated);
    }
    if (message.created !== 0) {
      writer.uint32(136).int64(message.created);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): PassportEntity {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBasePassportEntity();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.type = reader.string();
          break;
        case 2:
          message.value = reader.string();
          break;
        case 3:
          message.password = reader.string();
          break;
        case 4:
          message.confirmed = reader.bool();
          break;
        case 5:
          message.accessToken = reader.string();
          break;
        case 6:
          message.userId = reader.string();
          break;
        case 7:
          message.uniqueId = reader.string();
          break;
        case 16:
          message.updated = longToNumber(reader.int64() as Long);
          break;
        case 17:
          message.created = longToNumber(reader.int64() as Long);
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): PassportEntity {
    return {
      type: isSet(object.type) ? String(object.type) : "",
      value: isSet(object.value) ? String(object.value) : "",
      password: isSet(object.password) ? String(object.password) : "",
      confirmed: isSet(object.confirmed) ? Boolean(object.confirmed) : false,
      accessToken: isSet(object.accessToken) ? String(object.accessToken) : "",
      userId: isSet(object.userId) ? String(object.userId) : "",
      uniqueId: isSet(object.uniqueId) ? String(object.uniqueId) : "",
      updated: isSet(object.updated) ? Number(object.updated) : 0,
      created: isSet(object.created) ? Number(object.created) : 0,
    };
  },

  toJSON(message: PassportEntity): unknown {
    const obj: any = {};
    message.type !== undefined && (obj.type = message.type);
    message.value !== undefined && (obj.value = message.value);
    message.password !== undefined && (obj.password = message.password);
    message.confirmed !== undefined && (obj.confirmed = message.confirmed);
    message.accessToken !== undefined &&
      (obj.accessToken = message.accessToken);
    message.userId !== undefined && (obj.userId = message.userId);
    message.uniqueId !== undefined && (obj.uniqueId = message.uniqueId);
    message.updated !== undefined &&
      (obj.updated = Math.round(message.updated));
    message.created !== undefined &&
      (obj.created = Math.round(message.created));
    return obj;
  },

  create<I extends Exact<DeepPartial<PassportEntity>, I>>(
    base?: I
  ): PassportEntity {
    return PassportEntity.fromPartial(base ?? {});
  },

  fromPartial<I extends Exact<DeepPartial<PassportEntity>, I>>(
    object: I
  ): PassportEntity {
    const message = createBasePassportEntity();
    message.type = object.type ?? "";
    message.value = object.value ?? "";
    message.password = object.password ?? "";
    message.confirmed = object.confirmed ?? false;
    message.accessToken = object.accessToken ?? "";
    message.userId = object.userId ?? "";
    message.uniqueId = object.uniqueId ?? "";
    message.updated = object.updated ?? 0;
    message.created = object.created ?? 0;
    return message;
  },
};

function createBaseUserSessionDto(): UserSessionDto {
  return {
    passport: undefined,
    token: "",
    exchangeKey: "",
    userRoleWorkspaces: [],
    user: undefined,
  };
}

export const UserSessionDto = {
  encode(
    message: UserSessionDto,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.passport !== undefined) {
      PassportEntity.encode(
        message.passport,
        writer.uint32(10).fork()
      ).ldelim();
    }
    if (message.token !== "") {
      writer.uint32(18).string(message.token);
    }
    if (message.exchangeKey !== "") {
      writer.uint32(26).string(message.exchangeKey);
    }
    for (const v of message.userRoleWorkspaces) {
      UserRoleWorkspace.encode(v!, writer.uint32(34).fork()).ldelim();
    }
    if (message.user !== undefined) {
      UserEntity.encode(message.user, writer.uint32(42).fork()).ldelim();
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): UserSessionDto {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseUserSessionDto();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.passport = PassportEntity.decode(reader, reader.uint32());
          break;
        case 2:
          message.token = reader.string();
          break;
        case 3:
          message.exchangeKey = reader.string();
          break;
        case 4:
          message.userRoleWorkspaces.push(
            UserRoleWorkspace.decode(reader, reader.uint32())
          );
          break;
        case 5:
          message.user = UserEntity.decode(reader, reader.uint32());
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): UserSessionDto {
    return {
      passport: isSet(object.passport)
        ? PassportEntity.fromJSON(object.passport)
        : undefined,
      token: isSet(object.token) ? String(object.token) : "",
      exchangeKey: isSet(object.exchangeKey) ? String(object.exchangeKey) : "",
      userRoleWorkspaces: Array.isArray(object?.userRoleWorkspaces)
        ? object.userRoleWorkspaces.map((e: any) =>
            UserRoleWorkspace.fromJSON(e)
          )
        : [],
      user: isSet(object.user) ? UserEntity.fromJSON(object.user) : undefined,
    };
  },

  toJSON(message: UserSessionDto): unknown {
    const obj: any = {};
    message.passport !== undefined &&
      (obj.passport = message.passport
        ? PassportEntity.toJSON(message.passport)
        : undefined);
    message.token !== undefined && (obj.token = message.token);
    message.exchangeKey !== undefined &&
      (obj.exchangeKey = message.exchangeKey);
    if (message.userRoleWorkspaces) {
      obj.userRoleWorkspaces = message.userRoleWorkspaces.map((e) =>
        e ? UserRoleWorkspace.toJSON(e) : undefined
      );
    } else {
      obj.userRoleWorkspaces = [];
    }
    message.user !== undefined &&
      (obj.user = message.user ? UserEntity.toJSON(message.user) : undefined);
    return obj;
  },

  create<I extends Exact<DeepPartial<UserSessionDto>, I>>(
    base?: I
  ): UserSessionDto {
    return UserSessionDto.fromPartial(base ?? {});
  },

  fromPartial<I extends Exact<DeepPartial<UserSessionDto>, I>>(
    object: I
  ): UserSessionDto {
    const message = createBaseUserSessionDto();
    message.passport =
      object.passport !== undefined && object.passport !== null
        ? PassportEntity.fromPartial(object.passport)
        : undefined;
    message.token = object.token ?? "";
    message.exchangeKey = object.exchangeKey ?? "";
    message.userRoleWorkspaces =
      object.userRoleWorkspaces?.map((e) => UserRoleWorkspace.fromPartial(e)) ||
      [];
    message.user =
      object.user !== undefined && object.user !== null
        ? UserEntity.fromPartial(object.user)
        : undefined;
    return message;
  },
};

function createBasePublicJoinKey(): PublicJoinKey {
  return {
    workspace: undefined,
    workspaceId: undefined,
    role: undefined,
    roleId: undefined,
    uniqueId: "",
    visibility: undefined,
    updated: 0,
    created: 0,
  };
}

export const PublicJoinKey = {
  encode(
    message: PublicJoinKey,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.workspace !== undefined) {
      WorkspaceEntity.encode(
        message.workspace,
        writer.uint32(10).fork()
      ).ldelim();
    }
    if (message.workspaceId !== undefined) {
      writer.uint32(18).string(message.workspaceId);
    }
    if (message.role !== undefined) {
      RoleEntity.encode(message.role, writer.uint32(26).fork()).ldelim();
    }
    if (message.roleId !== undefined) {
      writer.uint32(34).string(message.roleId);
    }
    if (message.uniqueId !== "") {
      writer.uint32(42).string(message.uniqueId);
    }
    if (message.visibility !== undefined) {
      writer.uint32(50).string(message.visibility);
    }
    if (message.updated !== 0) {
      writer.uint32(128).int64(message.updated);
    }
    if (message.created !== 0) {
      writer.uint32(136).int64(message.created);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): PublicJoinKey {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBasePublicJoinKey();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.workspace = WorkspaceEntity.decode(reader, reader.uint32());
          break;
        case 2:
          message.workspaceId = reader.string();
          break;
        case 3:
          message.role = RoleEntity.decode(reader, reader.uint32());
          break;
        case 4:
          message.roleId = reader.string();
          break;
        case 5:
          message.uniqueId = reader.string();
          break;
        case 6:
          message.visibility = reader.string();
          break;
        case 16:
          message.updated = longToNumber(reader.int64() as Long);
          break;
        case 17:
          message.created = longToNumber(reader.int64() as Long);
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): PublicJoinKey {
    return {
      workspace: isSet(object.workspace)
        ? WorkspaceEntity.fromJSON(object.workspace)
        : undefined,
      workspaceId: isSet(object.workspaceId)
        ? String(object.workspaceId)
        : undefined,
      role: isSet(object.role) ? RoleEntity.fromJSON(object.role) : undefined,
      roleId: isSet(object.roleId) ? String(object.roleId) : undefined,
      uniqueId: isSet(object.uniqueId) ? String(object.uniqueId) : "",
      visibility: isSet(object.visibility)
        ? String(object.visibility)
        : undefined,
      updated: isSet(object.updated) ? Number(object.updated) : 0,
      created: isSet(object.created) ? Number(object.created) : 0,
    };
  },

  toJSON(message: PublicJoinKey): unknown {
    const obj: any = {};
    message.workspace !== undefined &&
      (obj.workspace = message.workspace
        ? WorkspaceEntity.toJSON(message.workspace)
        : undefined);
    message.workspaceId !== undefined &&
      (obj.workspaceId = message.workspaceId);
    message.role !== undefined &&
      (obj.role = message.role ? RoleEntity.toJSON(message.role) : undefined);
    message.roleId !== undefined && (obj.roleId = message.roleId);
    message.uniqueId !== undefined && (obj.uniqueId = message.uniqueId);
    message.visibility !== undefined && (obj.visibility = message.visibility);
    message.updated !== undefined &&
      (obj.updated = Math.round(message.updated));
    message.created !== undefined &&
      (obj.created = Math.round(message.created));
    return obj;
  },

  create<I extends Exact<DeepPartial<PublicJoinKey>, I>>(
    base?: I
  ): PublicJoinKey {
    return PublicJoinKey.fromPartial(base ?? {});
  },

  fromPartial<I extends Exact<DeepPartial<PublicJoinKey>, I>>(
    object: I
  ): PublicJoinKey {
    const message = createBasePublicJoinKey();
    message.workspace =
      object.workspace !== undefined && object.workspace !== null
        ? WorkspaceEntity.fromPartial(object.workspace)
        : undefined;
    message.workspaceId = object.workspaceId ?? undefined;
    message.role =
      object.role !== undefined && object.role !== null
        ? RoleEntity.fromPartial(object.role)
        : undefined;
    message.roleId = object.roleId ?? undefined;
    message.uniqueId = object.uniqueId ?? "";
    message.visibility = object.visibility ?? undefined;
    message.updated = object.updated ?? 0;
    message.created = object.created ?? 0;
    return message;
  },
};

function createBaseOtpAuthenticateDto(): OtpAuthenticateDto {
  return { value: "", otp: "", type: "", password: "" };
}

export const OtpAuthenticateDto = {
  encode(
    message: OtpAuthenticateDto,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.value !== "") {
      writer.uint32(10).string(message.value);
    }
    if (message.otp !== "") {
      writer.uint32(18).string(message.otp);
    }
    if (message.type !== "") {
      writer.uint32(26).string(message.type);
    }
    if (message.password !== "") {
      writer.uint32(34).string(message.password);
    }
    return writer;
  },

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

  fromJSON(object: any): OtpAuthenticateDto {
    return {
      value: isSet(object.value) ? String(object.value) : "",
      otp: isSet(object.otp) ? String(object.otp) : "",
      type: isSet(object.type) ? String(object.type) : "",
      password: isSet(object.password) ? String(object.password) : "",
    };
  },

  toJSON(message: OtpAuthenticateDto): unknown {
    const obj: any = {};
    message.value !== undefined && (obj.value = message.value);
    message.otp !== undefined && (obj.otp = message.otp);
    message.type !== undefined && (obj.type = message.type);
    message.password !== undefined && (obj.password = message.password);
    return obj;
  },

  create<I extends Exact<DeepPartial<OtpAuthenticateDto>, I>>(
    base?: I
  ): OtpAuthenticateDto {
    return OtpAuthenticateDto.fromPartial(base ?? {});
  },

  fromPartial<I extends Exact<DeepPartial<OtpAuthenticateDto>, I>>(
    object: I
  ): OtpAuthenticateDto {
    const message = createBaseOtpAuthenticateDto();
    message.value = object.value ?? "";
    message.otp = object.otp ?? "";
    message.type = object.type ?? "";
    message.password = object.password ?? "";
    return message;
  },
};

function createBaseEmailOtpResponse(): EmailOtpResponse {
  return { request: undefined, userSession: undefined };
}

export const EmailOtpResponse = {
  encode(
    message: EmailOtpResponse,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.request !== undefined) {
      ForgetPasswordEntity.encode(
        message.request,
        writer.uint32(10).fork()
      ).ldelim();
    }
    if (message.userSession !== undefined) {
      UserSessionDto.encode(
        message.userSession,
        writer.uint32(18).fork()
      ).ldelim();
    }
    return writer;
  },

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

  fromJSON(object: any): EmailOtpResponse {
    return {
      request: isSet(object.request)
        ? ForgetPasswordEntity.fromJSON(object.request)
        : undefined,
      userSession: isSet(object.userSession)
        ? UserSessionDto.fromJSON(object.userSession)
        : undefined,
    };
  },

  toJSON(message: EmailOtpResponse): unknown {
    const obj: any = {};
    message.request !== undefined &&
      (obj.request = message.request
        ? ForgetPasswordEntity.toJSON(message.request)
        : undefined);
    message.userSession !== undefined &&
      (obj.userSession = message.userSession
        ? UserSessionDto.toJSON(message.userSession)
        : undefined);
    return obj;
  },

  create<I extends Exact<DeepPartial<EmailOtpResponse>, I>>(
    base?: I
  ): EmailOtpResponse {
    return EmailOtpResponse.fromPartial(base ?? {});
  },

  fromPartial<I extends Exact<DeepPartial<EmailOtpResponse>, I>>(
    object: I
  ): EmailOtpResponse {
    const message = createBaseEmailOtpResponse();
    message.request =
      object.request !== undefined && object.request !== null
        ? ForgetPasswordEntity.fromPartial(object.request)
        : undefined;
    message.userSession =
      object.userSession !== undefined && object.userSession !== null
        ? UserSessionDto.fromPartial(object.userSession)
        : undefined;
    return message;
  },
};

function createBaseResetEmailDto(): ResetEmailDto {
  return { password: "" };
}

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

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

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

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

  create<I extends Exact<DeepPartial<ResetEmailDto>, I>>(
    base?: I
  ): ResetEmailDto {
    return ResetEmailDto.fromPartial(base ?? {});
  },

  fromPartial<I extends Exact<DeepPartial<ResetEmailDto>, I>>(
    object: I
  ): ResetEmailDto {
    const message = createBaseResetEmailDto();
    message.password = object.password ?? "";
    return message;
  },
};

function createBasePassportMethodCreateReply(): PassportMethodCreateReply {
  return { data: undefined, error: undefined };
}

export const PassportMethodCreateReply = {
  encode(
    message: PassportMethodCreateReply,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.data !== undefined) {
      PassportMethodEntity.encode(
        message.data,
        writer.uint32(10).fork()
      ).ldelim();
    }
    if (message.error !== undefined) {
      IError.encode(message.error, writer.uint32(18).fork()).ldelim();
    }
    return writer;
  },

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

  fromJSON(object: any): PassportMethodCreateReply {
    return {
      data: isSet(object.data)
        ? PassportMethodEntity.fromJSON(object.data)
        : undefined,
      error: isSet(object.error) ? IError.fromJSON(object.error) : undefined,
    };
  },

  toJSON(message: PassportMethodCreateReply): unknown {
    const obj: any = {};
    message.data !== undefined &&
      (obj.data = message.data
        ? PassportMethodEntity.toJSON(message.data)
        : undefined);
    message.error !== undefined &&
      (obj.error = message.error ? IError.toJSON(message.error) : undefined);
    return obj;
  },

  create<I extends Exact<DeepPartial<PassportMethodCreateReply>, I>>(
    base?: I
  ): PassportMethodCreateReply {
    return PassportMethodCreateReply.fromPartial(base ?? {});
  },

  fromPartial<I extends Exact<DeepPartial<PassportMethodCreateReply>, I>>(
    object: I
  ): PassportMethodCreateReply {
    const message = createBasePassportMethodCreateReply();
    message.data =
      object.data !== undefined && object.data !== null
        ? PassportMethodEntity.fromPartial(object.data)
        : undefined;
    message.error =
      object.error !== undefined && object.error !== null
        ? IError.fromPartial(object.error)
        : undefined;
    return message;
  },
};

function createBasePassportMethodReply(): PassportMethodReply {
  return { data: undefined, error: undefined };
}

export const PassportMethodReply = {
  encode(
    message: PassportMethodReply,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.data !== undefined) {
      PassportMethodEntity.encode(
        message.data,
        writer.uint32(10).fork()
      ).ldelim();
    }
    if (message.error !== undefined) {
      IError.encode(message.error, writer.uint32(18).fork()).ldelim();
    }
    return writer;
  },

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

  fromJSON(object: any): PassportMethodReply {
    return {
      data: isSet(object.data)
        ? PassportMethodEntity.fromJSON(object.data)
        : undefined,
      error: isSet(object.error) ? IError.fromJSON(object.error) : undefined,
    };
  },

  toJSON(message: PassportMethodReply): unknown {
    const obj: any = {};
    message.data !== undefined &&
      (obj.data = message.data
        ? PassportMethodEntity.toJSON(message.data)
        : undefined);
    message.error !== undefined &&
      (obj.error = message.error ? IError.toJSON(message.error) : undefined);
    return obj;
  },

  create<I extends Exact<DeepPartial<PassportMethodReply>, I>>(
    base?: I
  ): PassportMethodReply {
    return PassportMethodReply.fromPartial(base ?? {});
  },

  fromPartial<I extends Exact<DeepPartial<PassportMethodReply>, I>>(
    object: I
  ): PassportMethodReply {
    const message = createBasePassportMethodReply();
    message.data =
      object.data !== undefined && object.data !== null
        ? PassportMethodEntity.fromPartial(object.data)
        : undefined;
    message.error =
      object.error !== undefined && object.error !== null
        ? IError.fromPartial(object.error)
        : undefined;
    return message;
  },
};

function createBasePassportMethodQueryReply(): PassportMethodQueryReply {
  return {
    items: [],
    totalItems: 0,
    itemsPerPage: 0,
    startIndex: 0,
    error: undefined,
  };
}

export const PassportMethodQueryReply = {
  encode(
    message: PassportMethodQueryReply,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    for (const v of message.items) {
      PassportMethodEntity.encode(v!, writer.uint32(10).fork()).ldelim();
    }
    if (message.totalItems !== 0) {
      writer.uint32(16).int64(message.totalItems);
    }
    if (message.itemsPerPage !== 0) {
      writer.uint32(24).int64(message.itemsPerPage);
    }
    if (message.startIndex !== 0) {
      writer.uint32(32).int64(message.startIndex);
    }
    if (message.error !== undefined) {
      IError.encode(message.error, writer.uint32(42).fork()).ldelim();
    }
    return writer;
  },

  decode(
    input: _m0.Reader | Uint8Array,
    length?: number
  ): PassportMethodQueryReply {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBasePassportMethodQueryReply();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.items.push(
            PassportMethodEntity.decode(reader, reader.uint32())
          );
          break;
        case 2:
          message.totalItems = longToNumber(reader.int64() as Long);
          break;
        case 3:
          message.itemsPerPage = longToNumber(reader.int64() as Long);
          break;
        case 4:
          message.startIndex = longToNumber(reader.int64() as Long);
          break;
        case 5:
          message.error = IError.decode(reader, reader.uint32());
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): PassportMethodQueryReply {
    return {
      items: Array.isArray(object?.items)
        ? object.items.map((e: any) => PassportMethodEntity.fromJSON(e))
        : [],
      totalItems: isSet(object.totalItems) ? Number(object.totalItems) : 0,
      itemsPerPage: isSet(object.itemsPerPage)
        ? Number(object.itemsPerPage)
        : 0,
      startIndex: isSet(object.startIndex) ? Number(object.startIndex) : 0,
      error: isSet(object.error) ? IError.fromJSON(object.error) : undefined,
    };
  },

  toJSON(message: PassportMethodQueryReply): unknown {
    const obj: any = {};
    if (message.items) {
      obj.items = message.items.map((e) =>
        e ? PassportMethodEntity.toJSON(e) : undefined
      );
    } else {
      obj.items = [];
    }
    message.totalItems !== undefined &&
      (obj.totalItems = Math.round(message.totalItems));
    message.itemsPerPage !== undefined &&
      (obj.itemsPerPage = Math.round(message.itemsPerPage));
    message.startIndex !== undefined &&
      (obj.startIndex = Math.round(message.startIndex));
    message.error !== undefined &&
      (obj.error = message.error ? IError.toJSON(message.error) : undefined);
    return obj;
  },

  create<I extends Exact<DeepPartial<PassportMethodQueryReply>, I>>(
    base?: I
  ): PassportMethodQueryReply {
    return PassportMethodQueryReply.fromPartial(base ?? {});
  },

  fromPartial<I extends Exact<DeepPartial<PassportMethodQueryReply>, I>>(
    object: I
  ): PassportMethodQueryReply {
    const message = createBasePassportMethodQueryReply();
    message.items =
      object.items?.map((e) => PassportMethodEntity.fromPartial(e)) || [];
    message.totalItems = object.totalItems ?? 0;
    message.itemsPerPage = object.itemsPerPage ?? 0;
    message.startIndex = object.startIndex ?? 0;
    message.error =
      object.error !== undefined && object.error !== null
        ? IError.fromPartial(object.error)
        : undefined;
    return message;
  },
};

function createBasePassportMethodEntity(): PassportMethodEntity {
  return {
    visibility: undefined,
    workspaceId: undefined,
    linkerId: undefined,
    parentId: undefined,
    uniqueId: "",
    userId: undefined,
    translations: [],
    name: undefined,
    type: undefined,
    region: undefined,
    rank: 0,
    updated: 0,
    created: 0,
    createdFormatted: "",
    updatedFormatted: "",
  };
}

export const PassportMethodEntity = {
  encode(
    message: PassportMethodEntity,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.visibility !== undefined) {
      writer.uint32(10).string(message.visibility);
    }
    if (message.workspaceId !== undefined) {
      writer.uint32(18).string(message.workspaceId);
    }
    if (message.linkerId !== undefined) {
      writer.uint32(26).string(message.linkerId);
    }
    if (message.parentId !== undefined) {
      writer.uint32(34).string(message.parentId);
    }
    if (message.uniqueId !== "") {
      writer.uint32(42).string(message.uniqueId);
    }
    if (message.userId !== undefined) {
      writer.uint32(50).string(message.userId);
    }
    for (const v of message.translations) {
      PassportMethodEntityPolyglot.encode(
        v!,
        writer.uint32(58).fork()
      ).ldelim();
    }
    if (message.name !== undefined) {
      writer.uint32(74).string(message.name);
    }
    if (message.type !== undefined) {
      writer.uint32(82).string(message.type);
    }
    if (message.region !== undefined) {
      writer.uint32(90).string(message.region);
    }
    if (message.rank !== 0) {
      writer.uint32(96).int64(message.rank);
    }
    if (message.updated !== 0) {
      writer.uint32(104).int64(message.updated);
    }
    if (message.created !== 0) {
      writer.uint32(112).int64(message.created);
    }
    if (message.createdFormatted !== "") {
      writer.uint32(122).string(message.createdFormatted);
    }
    if (message.updatedFormatted !== "") {
      writer.uint32(130).string(message.updatedFormatted);
    }
    return writer;
  },

  decode(
    input: _m0.Reader | Uint8Array,
    length?: number
  ): PassportMethodEntity {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBasePassportMethodEntity();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.visibility = reader.string();
          break;
        case 2:
          message.workspaceId = reader.string();
          break;
        case 3:
          message.linkerId = reader.string();
          break;
        case 4:
          message.parentId = reader.string();
          break;
        case 5:
          message.uniqueId = reader.string();
          break;
        case 6:
          message.userId = reader.string();
          break;
        case 7:
          message.translations.push(
            PassportMethodEntityPolyglot.decode(reader, reader.uint32())
          );
          break;
        case 9:
          message.name = reader.string();
          break;
        case 10:
          message.type = reader.string();
          break;
        case 11:
          message.region = reader.string();
          break;
        case 12:
          message.rank = longToNumber(reader.int64() as Long);
          break;
        case 13:
          message.updated = longToNumber(reader.int64() as Long);
          break;
        case 14:
          message.created = longToNumber(reader.int64() as Long);
          break;
        case 15:
          message.createdFormatted = reader.string();
          break;
        case 16:
          message.updatedFormatted = reader.string();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): PassportMethodEntity {
    return {
      visibility: isSet(object.visibility)
        ? String(object.visibility)
        : undefined,
      workspaceId: isSet(object.workspaceId)
        ? String(object.workspaceId)
        : undefined,
      linkerId: isSet(object.linkerId) ? String(object.linkerId) : undefined,
      parentId: isSet(object.parentId) ? String(object.parentId) : undefined,
      uniqueId: isSet(object.uniqueId) ? String(object.uniqueId) : "",
      userId: isSet(object.userId) ? String(object.userId) : undefined,
      translations: Array.isArray(object?.translations)
        ? object.translations.map((e: any) =>
            PassportMethodEntityPolyglot.fromJSON(e)
          )
        : [],
      name: isSet(object.name) ? String(object.name) : undefined,
      type: isSet(object.type) ? String(object.type) : undefined,
      region: isSet(object.region) ? String(object.region) : undefined,
      rank: isSet(object.rank) ? Number(object.rank) : 0,
      updated: isSet(object.updated) ? Number(object.updated) : 0,
      created: isSet(object.created) ? Number(object.created) : 0,
      createdFormatted: isSet(object.createdFormatted)
        ? String(object.createdFormatted)
        : "",
      updatedFormatted: isSet(object.updatedFormatted)
        ? String(object.updatedFormatted)
        : "",
    };
  },

  toJSON(message: PassportMethodEntity): unknown {
    const obj: any = {};
    message.visibility !== undefined && (obj.visibility = message.visibility);
    message.workspaceId !== undefined &&
      (obj.workspaceId = message.workspaceId);
    message.linkerId !== undefined && (obj.linkerId = message.linkerId);
    message.parentId !== undefined && (obj.parentId = message.parentId);
    message.uniqueId !== undefined && (obj.uniqueId = message.uniqueId);
    message.userId !== undefined && (obj.userId = message.userId);
    if (message.translations) {
      obj.translations = message.translations.map((e) =>
        e ? PassportMethodEntityPolyglot.toJSON(e) : undefined
      );
    } else {
      obj.translations = [];
    }
    message.name !== undefined && (obj.name = message.name);
    message.type !== undefined && (obj.type = message.type);
    message.region !== undefined && (obj.region = message.region);
    message.rank !== undefined && (obj.rank = Math.round(message.rank));
    message.updated !== undefined &&
      (obj.updated = Math.round(message.updated));
    message.created !== undefined &&
      (obj.created = Math.round(message.created));
    message.createdFormatted !== undefined &&
      (obj.createdFormatted = message.createdFormatted);
    message.updatedFormatted !== undefined &&
      (obj.updatedFormatted = message.updatedFormatted);
    return obj;
  },

  create<I extends Exact<DeepPartial<PassportMethodEntity>, I>>(
    base?: I
  ): PassportMethodEntity {
    return PassportMethodEntity.fromPartial(base ?? {});
  },

  fromPartial<I extends Exact<DeepPartial<PassportMethodEntity>, I>>(
    object: I
  ): PassportMethodEntity {
    const message = createBasePassportMethodEntity();
    message.visibility = object.visibility ?? undefined;
    message.workspaceId = object.workspaceId ?? undefined;
    message.linkerId = object.linkerId ?? undefined;
    message.parentId = object.parentId ?? undefined;
    message.uniqueId = object.uniqueId ?? "";
    message.userId = object.userId ?? undefined;
    message.translations =
      object.translations?.map((e) =>
        PassportMethodEntityPolyglot.fromPartial(e)
      ) || [];
    message.name = object.name ?? undefined;
    message.type = object.type ?? undefined;
    message.region = object.region ?? undefined;
    message.rank = object.rank ?? 0;
    message.updated = object.updated ?? 0;
    message.created = object.created ?? 0;
    message.createdFormatted = object.createdFormatted ?? "";
    message.updatedFormatted = object.updatedFormatted ?? "";
    return message;
  },
};

function createBasePassportMethodEntityPolyglot(): PassportMethodEntityPolyglot {
  return { linkerId: "", languageId: "", name: "" };
}

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

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

  fromJSON(object: any): PassportMethodEntityPolyglot {
    return {
      linkerId: isSet(object.linkerId) ? String(object.linkerId) : "",
      languageId: isSet(object.languageId) ? String(object.languageId) : "",
      name: isSet(object.name) ? String(object.name) : "",
    };
  },

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

  create<I extends Exact<DeepPartial<PassportMethodEntityPolyglot>, I>>(
    base?: I
  ): PassportMethodEntityPolyglot {
    return PassportMethodEntityPolyglot.fromPartial(base ?? {});
  },

  fromPartial<I extends Exact<DeepPartial<PassportMethodEntityPolyglot>, I>>(
    object: I
  ): PassportMethodEntityPolyglot {
    const message = createBasePassportMethodEntityPolyglot();
    message.linkerId = object.linkerId ?? "";
    message.languageId = object.languageId ?? "";
    message.name = object.name ?? "";
    return message;
  },
};

export interface Passports {
  PassportActionEmailSignup(
    request: EmailAccountSignupDto
  ): Promise<CreateByMailResponse>;
}

export class PassportsClientImpl implements Passports {
  private readonly rpc: Rpc;
  private readonly service: string;
  constructor(rpc: Rpc, opts?: { service?: string }) {
    this.service = opts?.service || "Passports";
    this.rpc = rpc;
    this.PassportActionEmailSignup = this.PassportActionEmailSignup.bind(this);
  }
  PassportActionEmailSignup(
    request: EmailAccountSignupDto
  ): Promise<CreateByMailResponse> {
    const data = EmailAccountSignupDto.encode(request).finish();
    const promise = this.rpc.request(
      this.service,
      "PassportActionEmailSignup",
      data
    );
    return promise.then((data) =>
      CreateByMailResponse.decode(new _m0.Reader(data))
    );
  }
}

export interface PassportMethods {
  PassportMethodActionCreate(
    request: PassportMethodEntity
  ): Promise<PassportMethodCreateReply>;
  PassportMethodActionUpdate(
    request: PassportMethodEntity
  ): Promise<PassportMethodCreateReply>;
  PassportMethodActionQuery(
    request: QueryFilterRequest
  ): Promise<PassportMethodQueryReply>;
  PassportMethodActionGetOne(
    request: QueryFilterRequest
  ): Promise<PassportMethodReply>;
  PassportMethodActionRemove(request: QueryFilterRequest): Promise<RemoveReply>;
}

export class PassportMethodsClientImpl implements PassportMethods {
  private readonly rpc: Rpc;
  private readonly service: string;
  constructor(rpc: Rpc, opts?: { service?: string }) {
    this.service = opts?.service || "PassportMethods";
    this.rpc = rpc;
    this.PassportMethodActionCreate =
      this.PassportMethodActionCreate.bind(this);
    this.PassportMethodActionUpdate =
      this.PassportMethodActionUpdate.bind(this);
    this.PassportMethodActionQuery = this.PassportMethodActionQuery.bind(this);
    this.PassportMethodActionGetOne =
      this.PassportMethodActionGetOne.bind(this);
    this.PassportMethodActionRemove =
      this.PassportMethodActionRemove.bind(this);
  }
  PassportMethodActionCreate(
    request: PassportMethodEntity
  ): Promise<PassportMethodCreateReply> {
    const data = PassportMethodEntity.encode(request).finish();
    const promise = this.rpc.request(
      this.service,
      "PassportMethodActionCreate",
      data
    );
    return promise.then((data) =>
      PassportMethodCreateReply.decode(new _m0.Reader(data))
    );
  }

  PassportMethodActionUpdate(
    request: PassportMethodEntity
  ): Promise<PassportMethodCreateReply> {
    const data = PassportMethodEntity.encode(request).finish();
    const promise = this.rpc.request(
      this.service,
      "PassportMethodActionUpdate",
      data
    );
    return promise.then((data) =>
      PassportMethodCreateReply.decode(new _m0.Reader(data))
    );
  }

  PassportMethodActionQuery(
    request: QueryFilterRequest
  ): Promise<PassportMethodQueryReply> {
    const data = QueryFilterRequest.encode(request).finish();
    const promise = this.rpc.request(
      this.service,
      "PassportMethodActionQuery",
      data
    );
    return promise.then((data) =>
      PassportMethodQueryReply.decode(new _m0.Reader(data))
    );
  }

  PassportMethodActionGetOne(
    request: QueryFilterRequest
  ): Promise<PassportMethodReply> {
    const data = QueryFilterRequest.encode(request).finish();
    const promise = this.rpc.request(
      this.service,
      "PassportMethodActionGetOne",
      data
    );
    return promise.then((data) =>
      PassportMethodReply.decode(new _m0.Reader(data))
    );
  }

  PassportMethodActionRemove(
    request: QueryFilterRequest
  ): Promise<RemoveReply> {
    const data = QueryFilterRequest.encode(request).finish();
    const promise = this.rpc.request(
      this.service,
      "PassportMethodActionRemove",
      data
    );
    return promise.then((data) => RemoveReply.decode(new _m0.Reader(data)));
  }
}

interface Rpc {
  request(
    service: string,
    method: string,
    data: Uint8Array
  ): Promise<Uint8Array>;
}

declare var self: any | undefined;
declare var window: any | undefined;
declare var global: any | undefined;
var tsProtoGlobalThis: 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]> } & {
      [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
    };

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

if (_m0.util.Long !== Long) {
  _m0.util.Long = Long as any;
  _m0.configure();
}

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