cognito_http.pb.go

// Code generated by protoc-gen-go-server. DO NOT EDIT.
// See https://github.com/eolymp/contracts/tree/main/cmd/protoc-gen-go-server for more details.

package cognito

import (
	context "context"
	fmt "fmt"
	mux "github.com/gorilla/mux"
	websocket "golang.org/x/net/websocket"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	metadata "google.golang.org/grpc/metadata"
	status "google.golang.org/grpc/status"
	protojson "google.golang.org/protobuf/encoding/protojson"
	proto "google.golang.org/protobuf/proto"
	ioutil "io/ioutil"
	http "net/http"
)

// _Cognito_HTTPReadQueryString parses body into proto.Message
func _Cognito_HTTPReadQueryString(r *http.Request, v proto.Message) error {
	query := r.URL.Query().Get("q")
	if query == "" {
		return nil
	}

	if err := (protojson.UnmarshalOptions{DiscardUnknown: true}.Unmarshal([]byte(query), v)); err != nil {
		return err
	}

	return nil
}

// _Cognito_HTTPReadRequestBody parses body into proto.Message
func _Cognito_HTTPReadRequestBody(r *http.Request, v proto.Message) error {
	data, err := ioutil.ReadAll(r.Body)
	if err != nil {
		return err
	}

	if err := (protojson.UnmarshalOptions{DiscardUnknown: true}.Unmarshal(data, v)); err != nil {
		return err
	}

	return nil
}

// _Cognito_HTTPWriteResponse writes proto.Message to HTTP response
func _Cognito_HTTPWriteResponse(w http.ResponseWriter, v proto.Message, h, t metadata.MD) {
	data, err := protojson.Marshal(v)
	if err != nil {
		_Cognito_HTTPWriteErrorResponse(w, err)
		return
	}

	w.Header().Set("Content-Type", "application/json")

	if v := append(h.Get("cache-control"), t.Get("cache-control")...); len(v) > 0 {
		w.Header().Set("Cache-Control", v[len(v)-1])
	}

	if v := append(h.Get("etag"), t.Get("etag")...); len(v) > 0 {
		w.Header().Set("ETag", v[len(v)-1])
	}

	if v := append(h.Get("last-modified"), t.Get("last-modified")...); len(v) > 0 {
		w.Header().Set("Last-Modified", v[len(v)-1])
	}

	w.WriteHeader(http.StatusOK)

	_, _ = w.Write(data)
}

// _Cognito_HTTPWriteErrorResponse writes error to HTTP response with error status code
func _Cognito_HTTPWriteErrorResponse(w http.ResponseWriter, e error) {
	s := status.Convert(e)

	w.Header().Set("Content-Type", "application/json")

	switch s.Code() {
	case codes.OK:
		w.WriteHeader(http.StatusOK)
	case codes.Canceled:
		w.WriteHeader(http.StatusGatewayTimeout)
	case codes.Unknown:
		w.WriteHeader(http.StatusInternalServerError)
	case codes.InvalidArgument:
		w.WriteHeader(http.StatusBadRequest)
	case codes.DeadlineExceeded:
		w.WriteHeader(http.StatusGatewayTimeout)
	case codes.NotFound:
		w.WriteHeader(http.StatusNotFound)
	case codes.AlreadyExists:
		w.WriteHeader(http.StatusConflict)
	case codes.PermissionDenied:
		w.WriteHeader(http.StatusForbidden)
	case codes.ResourceExhausted:
		w.WriteHeader(http.StatusTooManyRequests)
	case codes.FailedPrecondition:
		w.WriteHeader(http.StatusPreconditionFailed)
	case codes.Aborted:
		w.WriteHeader(http.StatusServiceUnavailable)
	case codes.OutOfRange:
		w.WriteHeader(http.StatusRequestedRangeNotSatisfiable)
	case codes.Unimplemented:
		w.WriteHeader(http.StatusNotImplemented)
	case codes.Internal:
		w.WriteHeader(http.StatusInternalServerError)
	case codes.Unavailable:
		w.WriteHeader(http.StatusServiceUnavailable)
	case codes.DataLoss:
		w.WriteHeader(http.StatusInternalServerError)
	case codes.Unauthenticated:
		w.WriteHeader(http.StatusUnauthorized)
	default:
		w.WriteHeader(http.StatusInternalServerError)
	}

	data, err := protojson.Marshal(s.Proto())
	if err != nil {
		panic(err)
	}

	_, _ = w.Write(data)
}

// _Cognito_WebsocketErrorResponse writes error to websocket connection
func _Cognito_WebsocketErrorResponse(conn *websocket.Conn, e error) {
	switch status.Convert(e).Code() {
	case codes.OK:
		conn.WriteClose(1000)
	case codes.Canceled:
		conn.WriteClose(1000)
	case codes.Unknown:
		conn.WriteClose(1011)
	case codes.InvalidArgument:
		conn.WriteClose(1003)
	case codes.DeadlineExceeded:
		conn.WriteClose(1000)
	case codes.NotFound:
		conn.WriteClose(1000)
	case codes.AlreadyExists:
		conn.WriteClose(1000)
	case codes.PermissionDenied:
		conn.WriteClose(1000)
	case codes.ResourceExhausted:
		conn.WriteClose(1000)
	case codes.FailedPrecondition:
		conn.WriteClose(1000)
	case codes.Aborted:
		conn.WriteClose(1000)
	case codes.OutOfRange:
		conn.WriteClose(1000)
	case codes.Unimplemented:
		conn.WriteClose(1011)
	case codes.Internal:
		conn.WriteClose(1011)
	case codes.Unavailable:
		conn.WriteClose(1011)
	case codes.DataLoss:
		conn.WriteClose(1011)
	case codes.Unauthenticated:
		conn.WriteClose(1000)
	default:
		conn.WriteClose(1000)
	}
}

// _Cognito_WebsocketCodec implements protobuf codec for websockets package
var _Cognito_WebsocketCodec = websocket.Codec{
	Marshal: func(v interface{}) ([]byte, byte, error) {
		m, ok := v.(proto.Message)
		if !ok {
			panic(fmt.Errorf("invalid message type %T", v))
		}

		d, err := protojson.Marshal(m)
		if err != nil {
			return nil, 0, err
		}

		return d, websocket.TextFrame, err
	},
	Unmarshal: func(d []byte, t byte, v interface{}) error {
		m, ok := v.(proto.Message)
		if !ok {
			panic(fmt.Errorf("invalid message type %T", v))
		}

		return protojson.UnmarshalOptions{DiscardUnknown: true}.Unmarshal(d, m)
	},
}

// RegisterCognitoHttpHandlers adds handlers for for CognitoClient
// This constructor creates http.Handler, the actual implementation might change at any moment
func RegisterCognitoHttpHandlers(router *mux.Router, prefix string, cli CognitoClient) {
	router.Handle(prefix+"/self/signout", _Cognito_Signout_Rule0(cli)).
		Methods("POST").
		Name("eolymp.cognito.Cognito.Signout")
	router.Handle(prefix+"/access-keys", _Cognito_CreateAccessKey_Rule0(cli)).
		Methods("POST").
		Name("eolymp.cognito.Cognito.CreateAccessKey")
	router.Handle(prefix+"/access-keys/{key_id}", _Cognito_DeleteAccessKey_Rule0(cli)).
		Methods("DELETE").
		Name("eolymp.cognito.Cognito.DeleteAccessKey")
	router.Handle(prefix+"/access-keys", _Cognito_ListAccessKeys_Rule0(cli)).
		Methods("GET").
		Name("eolymp.cognito.Cognito.ListAccessKeys")
	router.Handle(prefix+"/users", _Cognito_CreateUser_Rule0(cli)).
		Methods("POST").
		Name("eolymp.cognito.Cognito.CreateUser")
	router.Handle(prefix+"/users/{user_id}/verify", _Cognito_VerifyEmail_Rule0(cli)).
		Methods("POST").
		Name("eolymp.cognito.Cognito.VerifyEmail")
	router.Handle(prefix+"/self/email/resend-verification", _Cognito_ResendEmailVerification_Rule0(cli)).
		Methods("POST").
		Name("eolymp.cognito.Cognito.ResendEmailVerification")
	router.Handle(prefix+"/self/email", _Cognito_UpdateEmail_Rule0(cli)).
		Methods("POST").
		Name("eolymp.cognito.Cognito.UpdateEmail")
	router.Handle(prefix+"/self", _Cognito_UpdateProfile_Rule0(cli)).
		Methods("POST").
		Name("eolymp.cognito.Cognito.UpdateProfile")
	router.Handle(prefix+"/self/picture", _Cognito_UpdatePicture_Rule0(cli)).
		Methods("POST").
		Name("eolymp.cognito.Cognito.UpdatePicture")
	router.Handle(prefix+"/self/password", _Cognito_UpdatePassword_Rule0(cli)).
		Methods("POST").
		Name("eolymp.cognito.Cognito.UpdatePassword")
	router.Handle(prefix+"/self", _Cognito_IntrospectUser_Rule0(cli)).
		Methods("GET").
		Name("eolymp.cognito.Cognito.IntrospectUser")
	router.Handle(prefix+"/users/{user_id}", _Cognito_DescribeUser_Rule0(cli)).
		Methods("GET").
		Name("eolymp.cognito.Cognito.DescribeUser")
	router.Handle(prefix+"/users", _Cognito_ListUsers_Rule0(cli)).
		Methods("GET").
		Name("eolymp.cognito.Cognito.ListUsers")
	router.Handle(prefix+"/self/quota", _Cognito_IntrospectQuota_Rule0(cli)).
		Methods("GET").
		Name("eolymp.cognito.Cognito.IntrospectQuota")
	router.Handle(prefix+"/self/roles", _Cognito_IntrospectRoles_Rule0(cli)).
		Methods("GET").
		Name("eolymp.cognito.Cognito.IntrospectRoles")
	router.Handle(prefix+"/users/{user_id}/roles", _Cognito_ListRoles_Rule0(cli)).
		Methods("GET").
		Name("eolymp.cognito.Cognito.ListRoles")
	router.Handle(prefix+"/users/{user_id}/roles", _Cognito_UpdateRoles_Rule0(cli)).
		Methods("PUT").
		Name("eolymp.cognito.Cognito.UpdateRoles")
	router.Handle(prefix+"/self/recovery", _Cognito_StartRecovery_Rule0(cli)).
		Methods("POST").
		Name("eolymp.cognito.Cognito.StartRecovery")
	router.Handle(prefix+"/users/{user_id}/recover", _Cognito_CompleteRecovery_Rule0(cli)).
		Methods("POST").
		Name("eolymp.cognito.Cognito.CompleteRecovery")
	router.Handle(prefix+"/self", _Cognito_SelfDestruct_Rule0(cli)).
		Methods("DELETE").
		Name("eolymp.cognito.Cognito.SelfDestruct")
}

func _Cognito_Signout_Rule0(cli CognitoClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &SignoutInput{}

		if err := _Cognito_HTTPReadRequestBody(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		var header, trailer metadata.MD

		out, err := cli.Signout(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		_Cognito_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Cognito_CreateAccessKey_Rule0(cli CognitoClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &CreateAccessKeyInput{}

		if err := _Cognito_HTTPReadRequestBody(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		var header, trailer metadata.MD

		out, err := cli.CreateAccessKey(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		_Cognito_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Cognito_DeleteAccessKey_Rule0(cli CognitoClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &DeleteAccessKeyInput{}

		if err := _Cognito_HTTPReadRequestBody(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		vars := mux.Vars(r)
		in.KeyId = vars["key_id"]

		var header, trailer metadata.MD

		out, err := cli.DeleteAccessKey(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		_Cognito_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Cognito_ListAccessKeys_Rule0(cli CognitoClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &ListAccessKeysInput{}

		if err := _Cognito_HTTPReadQueryString(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		var header, trailer metadata.MD

		out, err := cli.ListAccessKeys(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		_Cognito_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Cognito_CreateUser_Rule0(cli CognitoClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &CreateUserInput{}

		if err := _Cognito_HTTPReadRequestBody(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		var header, trailer metadata.MD

		out, err := cli.CreateUser(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		_Cognito_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Cognito_VerifyEmail_Rule0(cli CognitoClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &VerifyEmailInput{}

		if err := _Cognito_HTTPReadRequestBody(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		vars := mux.Vars(r)
		in.UserId = vars["user_id"]

		var header, trailer metadata.MD

		out, err := cli.VerifyEmail(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		_Cognito_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Cognito_ResendEmailVerification_Rule0(cli CognitoClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &ResendEmailVerificationInput{}

		if err := _Cognito_HTTPReadRequestBody(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		var header, trailer metadata.MD

		out, err := cli.ResendEmailVerification(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		_Cognito_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Cognito_UpdateEmail_Rule0(cli CognitoClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &UpdateEmailInput{}

		if err := _Cognito_HTTPReadRequestBody(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		var header, trailer metadata.MD

		out, err := cli.UpdateEmail(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		_Cognito_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Cognito_UpdateProfile_Rule0(cli CognitoClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &UpdateProfileInput{}

		if err := _Cognito_HTTPReadRequestBody(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		var header, trailer metadata.MD

		out, err := cli.UpdateProfile(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		_Cognito_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Cognito_UpdatePicture_Rule0(cli CognitoClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &UpdatePictureInput{}

		if err := _Cognito_HTTPReadRequestBody(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		var header, trailer metadata.MD

		out, err := cli.UpdatePicture(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		_Cognito_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Cognito_UpdatePassword_Rule0(cli CognitoClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &UpdatePasswordInput{}

		if err := _Cognito_HTTPReadRequestBody(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		var header, trailer metadata.MD

		out, err := cli.UpdatePassword(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		_Cognito_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Cognito_IntrospectUser_Rule0(cli CognitoClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &IntrospectUserInput{}

		if err := _Cognito_HTTPReadQueryString(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		var header, trailer metadata.MD

		out, err := cli.IntrospectUser(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		_Cognito_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Cognito_DescribeUser_Rule0(cli CognitoClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &DescribeUserInput{}

		if err := _Cognito_HTTPReadQueryString(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		vars := mux.Vars(r)
		in.UserId = vars["user_id"]

		var header, trailer metadata.MD

		out, err := cli.DescribeUser(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		_Cognito_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Cognito_ListUsers_Rule0(cli CognitoClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &ListUsersInput{}

		if err := _Cognito_HTTPReadQueryString(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		var header, trailer metadata.MD

		out, err := cli.ListUsers(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		_Cognito_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Cognito_IntrospectQuota_Rule0(cli CognitoClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &IntrospectQuotaInput{}

		if err := _Cognito_HTTPReadQueryString(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		var header, trailer metadata.MD

		out, err := cli.IntrospectQuota(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		_Cognito_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Cognito_IntrospectRoles_Rule0(cli CognitoClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &IntrospectRolesInput{}

		if err := _Cognito_HTTPReadQueryString(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		var header, trailer metadata.MD

		out, err := cli.IntrospectRoles(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		_Cognito_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Cognito_ListRoles_Rule0(cli CognitoClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &ListRolesInput{}

		if err := _Cognito_HTTPReadQueryString(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		vars := mux.Vars(r)
		in.UserId = vars["user_id"]

		var header, trailer metadata.MD

		out, err := cli.ListRoles(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		_Cognito_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Cognito_UpdateRoles_Rule0(cli CognitoClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &UpdateRolesInput{}

		if err := _Cognito_HTTPReadRequestBody(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		vars := mux.Vars(r)
		in.UserId = vars["user_id"]

		var header, trailer metadata.MD

		out, err := cli.UpdateRoles(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		_Cognito_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Cognito_StartRecovery_Rule0(cli CognitoClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &StartRecoveryInput{}

		if err := _Cognito_HTTPReadRequestBody(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		var header, trailer metadata.MD

		out, err := cli.StartRecovery(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		_Cognito_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Cognito_CompleteRecovery_Rule0(cli CognitoClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &CompleteRecoverInput{}

		if err := _Cognito_HTTPReadRequestBody(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		vars := mux.Vars(r)
		in.UserId = vars["user_id"]

		var header, trailer metadata.MD

		out, err := cli.CompleteRecovery(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		_Cognito_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Cognito_SelfDestruct_Rule0(cli CognitoClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &SelfDestructInput{}

		if err := _Cognito_HTTPReadRequestBody(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		var header, trailer metadata.MD

		out, err := cli.SelfDestruct(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Cognito_HTTPWriteErrorResponse(w, err)
			return
		}

		_Cognito_HTTPWriteResponse(w, out, header, trailer)
	})
}

type _CognitoHandler = func(ctx context.Context, in proto.Message) (proto.Message, error)
type _CognitoMiddleware = func(ctx context.Context, method string, in proto.Message, handler _CognitoHandler) (out proto.Message, err error)
type CognitoInterceptor struct {
	middleware []_CognitoMiddleware
	client     CognitoClient
}

// NewCognitoInterceptor constructs additional middleware for a server based on annotations in proto files
func NewCognitoInterceptor(cli CognitoClient, middleware ..._CognitoMiddleware) *CognitoInterceptor {
	return &CognitoInterceptor{client: cli, middleware: middleware}
}

func (i *CognitoInterceptor) CreateToken(ctx context.Context, in *CreateTokenInput, opts ...grpc.CallOption) (*CreateTokenOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*CreateTokenInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *CreateTokenInput, got %T", in))
		}

		return i.client.CreateToken(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.cognito.Cognito.CreateToken", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*CreateTokenOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *CreateTokenOutput, got %T", out))
	}

	return message, err
}

func (i *CognitoInterceptor) IntrospectToken(ctx context.Context, in *IntrospectTokenInput, opts ...grpc.CallOption) (*IntrospectTokenOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*IntrospectTokenInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *IntrospectTokenInput, got %T", in))
		}

		return i.client.IntrospectToken(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.cognito.Cognito.IntrospectToken", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*IntrospectTokenOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *IntrospectTokenOutput, got %T", out))
	}

	return message, err
}

func (i *CognitoInterceptor) RevokeToken(ctx context.Context, in *RevokeTokenInput, opts ...grpc.CallOption) (*RevokeTokenOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*RevokeTokenInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *RevokeTokenInput, got %T", in))
		}

		return i.client.RevokeToken(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.cognito.Cognito.RevokeToken", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*RevokeTokenOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *RevokeTokenOutput, got %T", out))
	}

	return message, err
}

func (i *CognitoInterceptor) Signout(ctx context.Context, in *SignoutInput, opts ...grpc.CallOption) (*SignoutOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*SignoutInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *SignoutInput, got %T", in))
		}

		return i.client.Signout(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.cognito.Cognito.Signout", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*SignoutOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *SignoutOutput, got %T", out))
	}

	return message, err
}

func (i *CognitoInterceptor) CreateAccessKey(ctx context.Context, in *CreateAccessKeyInput, opts ...grpc.CallOption) (*CreateAccessKeyOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*CreateAccessKeyInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *CreateAccessKeyInput, got %T", in))
		}

		return i.client.CreateAccessKey(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.cognito.Cognito.CreateAccessKey", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*CreateAccessKeyOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *CreateAccessKeyOutput, got %T", out))
	}

	return message, err
}

func (i *CognitoInterceptor) DeleteAccessKey(ctx context.Context, in *DeleteAccessKeyInput, opts ...grpc.CallOption) (*DeleteAccessKeyOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*DeleteAccessKeyInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *DeleteAccessKeyInput, got %T", in))
		}

		return i.client.DeleteAccessKey(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.cognito.Cognito.DeleteAccessKey", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*DeleteAccessKeyOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *DeleteAccessKeyOutput, got %T", out))
	}

	return message, err
}

func (i *CognitoInterceptor) ListAccessKeys(ctx context.Context, in *ListAccessKeysInput, opts ...grpc.CallOption) (*ListAccessKeysOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*ListAccessKeysInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *ListAccessKeysInput, got %T", in))
		}

		return i.client.ListAccessKeys(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.cognito.Cognito.ListAccessKeys", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*ListAccessKeysOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *ListAccessKeysOutput, got %T", out))
	}

	return message, err
}

func (i *CognitoInterceptor) CreateUser(ctx context.Context, in *CreateUserInput, opts ...grpc.CallOption) (*CreateUserOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*CreateUserInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *CreateUserInput, got %T", in))
		}

		return i.client.CreateUser(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.cognito.Cognito.CreateUser", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*CreateUserOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *CreateUserOutput, got %T", out))
	}

	return message, err
}

func (i *CognitoInterceptor) VerifyEmail(ctx context.Context, in *VerifyEmailInput, opts ...grpc.CallOption) (*VerifyEmailOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*VerifyEmailInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *VerifyEmailInput, got %T", in))
		}

		return i.client.VerifyEmail(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.cognito.Cognito.VerifyEmail", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*VerifyEmailOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *VerifyEmailOutput, got %T", out))
	}

	return message, err
}

func (i *CognitoInterceptor) ResendEmailVerification(ctx context.Context, in *ResendEmailVerificationInput, opts ...grpc.CallOption) (*ResendEmailVerificationOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*ResendEmailVerificationInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *ResendEmailVerificationInput, got %T", in))
		}

		return i.client.ResendEmailVerification(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.cognito.Cognito.ResendEmailVerification", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*ResendEmailVerificationOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *ResendEmailVerificationOutput, got %T", out))
	}

	return message, err
}

func (i *CognitoInterceptor) UpdateEmail(ctx context.Context, in *UpdateEmailInput, opts ...grpc.CallOption) (*UpdateEmailOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*UpdateEmailInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *UpdateEmailInput, got %T", in))
		}

		return i.client.UpdateEmail(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.cognito.Cognito.UpdateEmail", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*UpdateEmailOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *UpdateEmailOutput, got %T", out))
	}

	return message, err
}

func (i *CognitoInterceptor) UpdateProfile(ctx context.Context, in *UpdateProfileInput, opts ...grpc.CallOption) (*UpdateProfileOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*UpdateProfileInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *UpdateProfileInput, got %T", in))
		}

		return i.client.UpdateProfile(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.cognito.Cognito.UpdateProfile", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*UpdateProfileOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *UpdateProfileOutput, got %T", out))
	}

	return message, err
}

func (i *CognitoInterceptor) UpdatePicture(ctx context.Context, in *UpdatePictureInput, opts ...grpc.CallOption) (*UpdatePictureOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*UpdatePictureInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *UpdatePictureInput, got %T", in))
		}

		return i.client.UpdatePicture(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.cognito.Cognito.UpdatePicture", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*UpdatePictureOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *UpdatePictureOutput, got %T", out))
	}

	return message, err
}

func (i *CognitoInterceptor) UpdatePassword(ctx context.Context, in *UpdatePasswordInput, opts ...grpc.CallOption) (*UpdatePasswordOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*UpdatePasswordInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *UpdatePasswordInput, got %T", in))
		}

		return i.client.UpdatePassword(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.cognito.Cognito.UpdatePassword", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*UpdatePasswordOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *UpdatePasswordOutput, got %T", out))
	}

	return message, err
}

func (i *CognitoInterceptor) IntrospectUser(ctx context.Context, in *IntrospectUserInput, opts ...grpc.CallOption) (*IntrospectUserOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*IntrospectUserInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *IntrospectUserInput, got %T", in))
		}

		return i.client.IntrospectUser(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.cognito.Cognito.IntrospectUser", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*IntrospectUserOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *IntrospectUserOutput, got %T", out))
	}

	return message, err
}

func (i *CognitoInterceptor) DescribeUser(ctx context.Context, in *DescribeUserInput, opts ...grpc.CallOption) (*DescribeUserOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*DescribeUserInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *DescribeUserInput, got %T", in))
		}

		return i.client.DescribeUser(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.cognito.Cognito.DescribeUser", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*DescribeUserOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *DescribeUserOutput, got %T", out))
	}

	return message, err
}

func (i *CognitoInterceptor) ListUsers(ctx context.Context, in *ListUsersInput, opts ...grpc.CallOption) (*ListUsersOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*ListUsersInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *ListUsersInput, got %T", in))
		}

		return i.client.ListUsers(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.cognito.Cognito.ListUsers", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*ListUsersOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *ListUsersOutput, got %T", out))
	}

	return message, err
}

func (i *CognitoInterceptor) IntrospectQuota(ctx context.Context, in *IntrospectQuotaInput, opts ...grpc.CallOption) (*IntrospectQuotaOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*IntrospectQuotaInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *IntrospectQuotaInput, got %T", in))
		}

		return i.client.IntrospectQuota(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.cognito.Cognito.IntrospectQuota", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*IntrospectQuotaOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *IntrospectQuotaOutput, got %T", out))
	}

	return message, err
}

func (i *CognitoInterceptor) IntrospectRoles(ctx context.Context, in *IntrospectRolesInput, opts ...grpc.CallOption) (*IntrospectRolesOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*IntrospectRolesInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *IntrospectRolesInput, got %T", in))
		}

		return i.client.IntrospectRoles(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.cognito.Cognito.IntrospectRoles", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*IntrospectRolesOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *IntrospectRolesOutput, got %T", out))
	}

	return message, err
}

func (i *CognitoInterceptor) ListRoles(ctx context.Context, in *ListRolesInput, opts ...grpc.CallOption) (*ListRolesOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*ListRolesInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *ListRolesInput, got %T", in))
		}

		return i.client.ListRoles(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.cognito.Cognito.ListRoles", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*ListRolesOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *ListRolesOutput, got %T", out))
	}

	return message, err
}

func (i *CognitoInterceptor) UpdateRoles(ctx context.Context, in *UpdateRolesInput, opts ...grpc.CallOption) (*UpdateRolesOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*UpdateRolesInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *UpdateRolesInput, got %T", in))
		}

		return i.client.UpdateRoles(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.cognito.Cognito.UpdateRoles", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*UpdateRolesOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *UpdateRolesOutput, got %T", out))
	}

	return message, err
}

func (i *CognitoInterceptor) StartRecovery(ctx context.Context, in *StartRecoveryInput, opts ...grpc.CallOption) (*StartRecoveryOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*StartRecoveryInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *StartRecoveryInput, got %T", in))
		}

		return i.client.StartRecovery(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.cognito.Cognito.StartRecovery", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*StartRecoveryOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *StartRecoveryOutput, got %T", out))
	}

	return message, err
}

func (i *CognitoInterceptor) CompleteRecovery(ctx context.Context, in *CompleteRecoverInput, opts ...grpc.CallOption) (*CompleteRecoverOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*CompleteRecoverInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *CompleteRecoverInput, got %T", in))
		}

		return i.client.CompleteRecovery(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.cognito.Cognito.CompleteRecovery", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*CompleteRecoverOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *CompleteRecoverOutput, got %T", out))
	}

	return message, err
}

func (i *CognitoInterceptor) SelfDestruct(ctx context.Context, in *SelfDestructInput, opts ...grpc.CallOption) (*SelfDestructOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*SelfDestructInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *SelfDestructInput, got %T", in))
		}

		return i.client.SelfDestruct(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.cognito.Cognito.SelfDestruct", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*SelfDestructOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *SelfDestructOutput, got %T", out))
	}

	return message, err
}