// Code generated by protoc-gen-go-errors. DO NOT EDIT.

package v1

import (
	context "context"
	errors "github.com/go-kratos/kratos/v2/errors"
	i18n "github.com/go-saas/go-i18n/v2/i18n"
	localize "github.com/go-saas/kit/pkg/localize"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the kratos package it is being compiled against.
const _ = errors.SupportPackageIsVersion1

func IsInvalidCredentials(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_INVALID_CREDENTIALS.String() && e.Code == 400
}

func ErrorInvalidCredentialsLocalized(ctx context.Context, data map[string]interface{}, pluralCount interface{}) *errors.Error {
	localizer := localize.FromContext(ctx)
	if localizer == nil {
		return errors.New(400, ErrorReason_INVALID_CREDENTIALS.String(), "")
	}
	msg, err := localizer.Localize(&i18n.LocalizeConfig{
		DefaultMessage: &i18n.Message{
			ID: "InvalidCredentials",
		},
		TemplateData: data,
		PluralCount:  pluralCount,
	})
	if err == nil {
		return errors.New(400, ErrorReason_INVALID_CREDENTIALS.String(), msg)
	} else {
		return errors.New(400, ErrorReason_INVALID_CREDENTIALS.String(), "")
	}
}

func IsInvalidOperation(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_INVALID_OPERATION.String() && e.Code == 400
}

func ErrorInvalidOperationLocalized(ctx context.Context, data map[string]interface{}, pluralCount interface{}) *errors.Error {
	localizer := localize.FromContext(ctx)
	if localizer == nil {
		return errors.New(400, ErrorReason_INVALID_OPERATION.String(), "")
	}
	msg, err := localizer.Localize(&i18n.LocalizeConfig{
		DefaultMessage: &i18n.Message{
			ID: "InvalidOperation",
		},
		TemplateData: data,
		PluralCount:  pluralCount,
	})
	if err == nil {
		return errors.New(400, ErrorReason_INVALID_OPERATION.String(), msg)
	} else {
		return errors.New(400, ErrorReason_INVALID_OPERATION.String(), "")
	}
}

func IsUserLocked(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_USER_LOCKED.String() && e.Code == 403
}

func ErrorUserLockedLocalized(ctx context.Context, data map[string]interface{}, pluralCount interface{}) *errors.Error {
	localizer := localize.FromContext(ctx)
	if localizer == nil {
		return errors.New(403, ErrorReason_USER_LOCKED.String(), "")
	}
	msg, err := localizer.Localize(&i18n.LocalizeConfig{
		DefaultMessage: &i18n.Message{
			ID: "UserLocked",
		},
		TemplateData: data,
		PluralCount:  pluralCount,
	})
	if err == nil {
		return errors.New(403, ErrorReason_USER_LOCKED.String(), msg)
	} else {
		return errors.New(403, ErrorReason_USER_LOCKED.String(), "")
	}
}

func IsEmailNotConfirmed(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_EMAIL_NOT_CONFIRMED.String() && e.Code == 403
}

func ErrorEmailNotConfirmedLocalized(ctx context.Context, data map[string]interface{}, pluralCount interface{}) *errors.Error {
	localizer := localize.FromContext(ctx)
	if localizer == nil {
		return errors.New(403, ErrorReason_EMAIL_NOT_CONFIRMED.String(), "")
	}
	msg, err := localizer.Localize(&i18n.LocalizeConfig{
		DefaultMessage: &i18n.Message{
			ID: "EmailNotConfirmed",
		},
		TemplateData: data,
		PluralCount:  pluralCount,
	})
	if err == nil {
		return errors.New(403, ErrorReason_EMAIL_NOT_CONFIRMED.String(), msg)
	} else {
		return errors.New(403, ErrorReason_EMAIL_NOT_CONFIRMED.String(), "")
	}
}

func IsPhoneNotConfirmed(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_PHONE_NOT_CONFIRMED.String() && e.Code == 403
}

func ErrorPhoneNotConfirmedLocalized(ctx context.Context, data map[string]interface{}, pluralCount interface{}) *errors.Error {
	localizer := localize.FromContext(ctx)
	if localizer == nil {
		return errors.New(403, ErrorReason_PHONE_NOT_CONFIRMED.String(), "")
	}
	msg, err := localizer.Localize(&i18n.LocalizeConfig{
		DefaultMessage: &i18n.Message{
			ID: "PhoneNotConfirmed",
		},
		TemplateData: data,
		PluralCount:  pluralCount,
	})
	if err == nil {
		return errors.New(403, ErrorReason_PHONE_NOT_CONFIRMED.String(), msg)
	} else {
		return errors.New(403, ErrorReason_PHONE_NOT_CONFIRMED.String(), "")
	}
}

func IsEmailRecoverFailed(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_EMAIL_RECOVER_FAILED.String() && e.Code == 403
}

func ErrorEmailRecoverFailedLocalized(ctx context.Context, data map[string]interface{}, pluralCount interface{}) *errors.Error {
	localizer := localize.FromContext(ctx)
	if localizer == nil {
		return errors.New(403, ErrorReason_EMAIL_RECOVER_FAILED.String(), "")
	}
	msg, err := localizer.Localize(&i18n.LocalizeConfig{
		DefaultMessage: &i18n.Message{
			ID: "EmailRecoverFailed",
		},
		TemplateData: data,
		PluralCount:  pluralCount,
	})
	if err == nil {
		return errors.New(403, ErrorReason_EMAIL_RECOVER_FAILED.String(), msg)
	} else {
		return errors.New(403, ErrorReason_EMAIL_RECOVER_FAILED.String(), "")
	}
}

func IsEmailConfirmFailed(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_EMAIL_CONFIRM_FAILED.String() && e.Code == 403
}

func ErrorEmailConfirmFailedLocalized(ctx context.Context, data map[string]interface{}, pluralCount interface{}) *errors.Error {
	localizer := localize.FromContext(ctx)
	if localizer == nil {
		return errors.New(403, ErrorReason_EMAIL_CONFIRM_FAILED.String(), "")
	}
	msg, err := localizer.Localize(&i18n.LocalizeConfig{
		DefaultMessage: &i18n.Message{
			ID: "EmailConfirmFailed",
		},
		TemplateData: data,
		PluralCount:  pluralCount,
	})
	if err == nil {
		return errors.New(403, ErrorReason_EMAIL_CONFIRM_FAILED.String(), msg)
	} else {
		return errors.New(403, ErrorReason_EMAIL_CONFIRM_FAILED.String(), "")
	}
}

func IsPhoneRecoverFailed(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_PHONE_RECOVER_FAILED.String() && e.Code == 403
}

func ErrorPhoneRecoverFailedLocalized(ctx context.Context, data map[string]interface{}, pluralCount interface{}) *errors.Error {
	localizer := localize.FromContext(ctx)
	if localizer == nil {
		return errors.New(403, ErrorReason_PHONE_RECOVER_FAILED.String(), "")
	}
	msg, err := localizer.Localize(&i18n.LocalizeConfig{
		DefaultMessage: &i18n.Message{
			ID: "PhoneRecoverFailed",
		},
		TemplateData: data,
		PluralCount:  pluralCount,
	})
	if err == nil {
		return errors.New(403, ErrorReason_PHONE_RECOVER_FAILED.String(), msg)
	} else {
		return errors.New(403, ErrorReason_PHONE_RECOVER_FAILED.String(), "")
	}
}

func IsPhoneConfirmFailed(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_PHONE_CONFIRM_FAILED.String() && e.Code == 403
}

func ErrorPhoneConfirmFailedLocalized(ctx context.Context, data map[string]interface{}, pluralCount interface{}) *errors.Error {
	localizer := localize.FromContext(ctx)
	if localizer == nil {
		return errors.New(403, ErrorReason_PHONE_CONFIRM_FAILED.String(), "")
	}
	msg, err := localizer.Localize(&i18n.LocalizeConfig{
		DefaultMessage: &i18n.Message{
			ID: "PhoneConfirmFailed",
		},
		TemplateData: data,
		PluralCount:  pluralCount,
	})
	if err == nil {
		return errors.New(403, ErrorReason_PHONE_CONFIRM_FAILED.String(), msg)
	} else {
		return errors.New(403, ErrorReason_PHONE_CONFIRM_FAILED.String(), "")
	}
}

func IsTwoStepFailed(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_TWO_STEP_FAILED.String() && e.Code == 400
}

func ErrorTwoStepFailedLocalized(ctx context.Context, data map[string]interface{}, pluralCount interface{}) *errors.Error {
	localizer := localize.FromContext(ctx)
	if localizer == nil {
		return errors.New(400, ErrorReason_TWO_STEP_FAILED.String(), "")
	}
	msg, err := localizer.Localize(&i18n.LocalizeConfig{
		DefaultMessage: &i18n.Message{
			ID: "TwoStepFailed",
		},
		TemplateData: data,
		PluralCount:  pluralCount,
	})
	if err == nil {
		return errors.New(400, ErrorReason_TWO_STEP_FAILED.String(), msg)
	} else {
		return errors.New(400, ErrorReason_TWO_STEP_FAILED.String(), "")
	}
}

func IsConfirmPasswordMismatch(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_CONFIRM_PASSWORD_MISMATCH.String() && e.Code == 400
}

func ErrorConfirmPasswordMismatchLocalized(ctx context.Context, data map[string]interface{}, pluralCount interface{}) *errors.Error {
	localizer := localize.FromContext(ctx)
	if localizer == nil {
		return errors.New(400, ErrorReason_CONFIRM_PASSWORD_MISMATCH.String(), "")
	}
	msg, err := localizer.Localize(&i18n.LocalizeConfig{
		DefaultMessage: &i18n.Message{
			ID: "ConfirmPasswordMismatch",
		},
		TemplateData: data,
		PluralCount:  pluralCount,
	})
	if err == nil {
		return errors.New(400, ErrorReason_CONFIRM_PASSWORD_MISMATCH.String(), msg)
	} else {
		return errors.New(400, ErrorReason_CONFIRM_PASSWORD_MISMATCH.String(), "")
	}
}

func IsRememberTokenNotFound(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_REMEMBER_TOKEN_NOT_FOUND.String() && e.Code == 403
}

func ErrorRememberTokenNotFoundLocalized(ctx context.Context, data map[string]interface{}, pluralCount interface{}) *errors.Error {
	localizer := localize.FromContext(ctx)
	if localizer == nil {
		return errors.New(403, ErrorReason_REMEMBER_TOKEN_NOT_FOUND.String(), "")
	}
	msg, err := localizer.Localize(&i18n.LocalizeConfig{
		DefaultMessage: &i18n.Message{
			ID: "RememberTokenNotFound",
		},
		TemplateData: data,
		PluralCount:  pluralCount,
	})
	if err == nil {
		return errors.New(403, ErrorReason_REMEMBER_TOKEN_NOT_FOUND.String(), msg)
	} else {
		return errors.New(403, ErrorReason_REMEMBER_TOKEN_NOT_FOUND.String(), "")
	}
}

func IsRememberTokenUsed(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_REMEMBER_TOKEN_USED.String() && e.Code == 403
}

func ErrorRememberTokenUsedLocalized(ctx context.Context, data map[string]interface{}, pluralCount interface{}) *errors.Error {
	localizer := localize.FromContext(ctx)
	if localizer == nil {
		return errors.New(403, ErrorReason_REMEMBER_TOKEN_USED.String(), "")
	}
	msg, err := localizer.Localize(&i18n.LocalizeConfig{
		DefaultMessage: &i18n.Message{
			ID: "RememberTokenUsed",
		},
		TemplateData: data,
		PluralCount:  pluralCount,
	})
	if err == nil {
		return errors.New(403, ErrorReason_REMEMBER_TOKEN_USED.String(), msg)
	} else {
		return errors.New(403, ErrorReason_REMEMBER_TOKEN_USED.String(), "")
	}
}

func IsUserDeleted(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_USER_DELETED.String() && e.Code == 403
}

func ErrorUserDeletedLocalized(ctx context.Context, data map[string]interface{}, pluralCount interface{}) *errors.Error {
	localizer := localize.FromContext(ctx)
	if localizer == nil {
		return errors.New(403, ErrorReason_USER_DELETED.String(), "")
	}
	msg, err := localizer.Localize(&i18n.LocalizeConfig{
		DefaultMessage: &i18n.Message{
			ID: "UserDeleted",
		},
		TemplateData: data,
		PluralCount:  pluralCount,
	})
	if err == nil {
		return errors.New(403, ErrorReason_USER_DELETED.String(), msg)
	} else {
		return errors.New(403, ErrorReason_USER_DELETED.String(), "")
	}
}

func IsRefreshTokenInvalid(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_REFRESH_TOKEN_INVALID.String() && e.Code == 401
}

func ErrorRefreshTokenInvalidLocalized(ctx context.Context, data map[string]interface{}, pluralCount interface{}) *errors.Error {
	localizer := localize.FromContext(ctx)
	if localizer == nil {
		return errors.New(401, ErrorReason_REFRESH_TOKEN_INVALID.String(), "")
	}
	msg, err := localizer.Localize(&i18n.LocalizeConfig{
		DefaultMessage: &i18n.Message{
			ID: "RefreshTokenInvalid",
		},
		TemplateData: data,
		PluralCount:  pluralCount,
	})
	if err == nil {
		return errors.New(401, ErrorReason_REFRESH_TOKEN_INVALID.String(), msg)
	} else {
		return errors.New(401, ErrorReason_REFRESH_TOKEN_INVALID.String(), "")
	}
}

func IsEmailPasswordlessFailed(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_EMAIL_PASSWORDLESS_FAILED.String() && e.Code == 403
}

func ErrorEmailPasswordlessFailedLocalized(ctx context.Context, data map[string]interface{}, pluralCount interface{}) *errors.Error {
	localizer := localize.FromContext(ctx)
	if localizer == nil {
		return errors.New(403, ErrorReason_EMAIL_PASSWORDLESS_FAILED.String(), "")
	}
	msg, err := localizer.Localize(&i18n.LocalizeConfig{
		DefaultMessage: &i18n.Message{
			ID: "EmailPasswordlessFailed",
		},
		TemplateData: data,
		PluralCount:  pluralCount,
	})
	if err == nil {
		return errors.New(403, ErrorReason_EMAIL_PASSWORDLESS_FAILED.String(), msg)
	} else {
		return errors.New(403, ErrorReason_EMAIL_PASSWORDLESS_FAILED.String(), "")
	}
}

func IsPhonePasswordlessFailed(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_PHONE_PASSWORDLESS_FAILED.String() && e.Code == 403
}

func ErrorPhonePasswordlessFailedLocalized(ctx context.Context, data map[string]interface{}, pluralCount interface{}) *errors.Error {
	localizer := localize.FromContext(ctx)
	if localizer == nil {
		return errors.New(403, ErrorReason_PHONE_PASSWORDLESS_FAILED.String(), "")
	}
	msg, err := localizer.Localize(&i18n.LocalizeConfig{
		DefaultMessage: &i18n.Message{
			ID: "PhonePasswordlessFailed",
		},
		TemplateData: data,
		PluralCount:  pluralCount,
	})
	if err == nil {
		return errors.New(403, ErrorReason_PHONE_PASSWORDLESS_FAILED.String(), msg)
	} else {
		return errors.New(403, ErrorReason_PHONE_PASSWORDLESS_FAILED.String(), "")
	}
}