account_service_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 community

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"
)

// _AccountService_HTTPReadQueryString parses body into proto.Message
func _AccountService_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
}

// _AccountService_HTTPReadRequestBody parses body into proto.Message
func _AccountService_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
}

// _AccountService_HTTPWriteResponse writes proto.Message to HTTP response
func _AccountService_HTTPWriteResponse(w http.ResponseWriter, v proto.Message, h, t metadata.MD) {
	data, err := protojson.Marshal(v)
	if err != nil {
		_AccountService_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)
}

// _AccountService_HTTPWriteErrorResponse writes error to HTTP response with error status code
func _AccountService_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)
}

// _AccountService_WebsocketErrorResponse writes error to websocket connection
func _AccountService_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)
	}
}

// _AccountService_WebsocketCodec implements protobuf codec for websockets package
var _AccountService_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)
	},
}

// RegisterAccountServiceHttpHandlers adds handlers for for AccountServiceClient
// This constructor creates http.Handler, the actual implementation might change at any moment
func RegisterAccountServiceHttpHandlers(router *mux.Router, prefix string, cli AccountServiceClient) {
	router.Handle(prefix+"/account", _AccountService_CreateAccount_Rule0(cli)).
		Methods("POST").
		Name("eolymp.community.AccountService.CreateAccount")
	router.Handle(prefix+"/account", _AccountService_DescribeAccount_Rule0(cli)).
		Methods("GET").
		Name("eolymp.community.AccountService.DescribeAccount")
	router.Handle(prefix+"/account", _AccountService_UpdateAccount_Rule0(cli)).
		Methods("PUT").
		Name("eolymp.community.AccountService.UpdateAccount")
	router.Handle(prefix+"/account/picture", _AccountService_UploadPicture_Rule0(cli)).
		Methods("POST").
		Name("eolymp.community.AccountService.UploadPicture")
	router.Handle(prefix+"/account", _AccountService_DeleteAccount_Rule0(cli)).
		Methods("DELETE").
		Name("eolymp.community.AccountService.DeleteAccount")
	router.Handle(prefix+"/account/verification/resend", _AccountService_ResendVerification_Rule0(cli)).
		Methods("POST").
		Name("eolymp.community.AccountService.ResendVerification")
	router.Handle(prefix+"/account/verification/complete", _AccountService_CompleteVerification_Rule0(cli)).
		Methods("POST").
		Name("eolymp.community.AccountService.CompleteVerification")
	router.Handle(prefix+"/account/recovery/start", _AccountService_StartRecovery_Rule0(cli)).
		Methods("POST").
		Name("eolymp.community.AccountService.StartRecovery")
	router.Handle(prefix+"/account/recovery/complete", _AccountService_CompleteRecovery_Rule0(cli)).
		Methods("POST").
		Name("eolymp.community.AccountService.CompleteRecovery")
	router.Handle(prefix+"/account/subscription", _AccountService_ConfigureActiveSubscription_Rule0(cli)).
		Methods("PUT").
		Name("eolymp.community.AccountService.ConfigureActiveSubscription")
	router.Handle(prefix+"/account/subscription", _AccountService_DescribeActiveSubscription_Rule0(cli)).
		Methods("GET").
		Name("eolymp.community.AccountService.DescribeActiveSubscription")
}

func _AccountService_CreateAccount_Rule0(cli AccountServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &CreateAccountInput{}

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

		var header, trailer metadata.MD

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

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

func _AccountService_DescribeAccount_Rule0(cli AccountServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &DescribeAccountInput{}

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

		var header, trailer metadata.MD

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

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

func _AccountService_UpdateAccount_Rule0(cli AccountServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &UpdateAccountInput{}

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

		var header, trailer metadata.MD

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

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

func _AccountService_UploadPicture_Rule0(cli AccountServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &UploadPictureInput{}

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

		var header, trailer metadata.MD

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

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

func _AccountService_DeleteAccount_Rule0(cli AccountServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &DeleteAccountInput{}

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

		var header, trailer metadata.MD

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

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

func _AccountService_ResendVerification_Rule0(cli AccountServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &ResendVerificationInput{}

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

		var header, trailer metadata.MD

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

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

func _AccountService_CompleteVerification_Rule0(cli AccountServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &CompleteVerificationInput{}

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

		var header, trailer metadata.MD

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

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

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

		if err := _AccountService_HTTPReadRequestBody(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_AccountService_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 {
			_AccountService_HTTPWriteErrorResponse(w, err)
			return
		}

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

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

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

		var header, trailer metadata.MD

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

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

func _AccountService_ConfigureActiveSubscription_Rule0(cli AccountServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &ConfigureActiveSubscriptionInput{}

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

		var header, trailer metadata.MD

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

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

func _AccountService_DescribeActiveSubscription_Rule0(cli AccountServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &DescribeActiveSubscriptionInput{}

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

		var header, trailer metadata.MD

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

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

type _AccountServiceHandler = func(ctx context.Context, in proto.Message) (proto.Message, error)
type _AccountServiceMiddleware = func(ctx context.Context, method string, in proto.Message, handler _AccountServiceHandler) (out proto.Message, err error)
type AccountServiceInterceptor struct {
	middleware []_AccountServiceMiddleware
	client     AccountServiceClient
}

// NewAccountServiceInterceptor constructs additional middleware for a server based on annotations in proto files
func NewAccountServiceInterceptor(cli AccountServiceClient, middleware ..._AccountServiceMiddleware) *AccountServiceInterceptor {
	return &AccountServiceInterceptor{client: cli, middleware: middleware}
}

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

		return i.client.CreateAccount(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.community.AccountService.CreateAccount", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.DescribeAccount(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.community.AccountService.DescribeAccount", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.UpdateAccount(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.community.AccountService.UpdateAccount", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.UploadPicture(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.community.AccountService.UploadPicture", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.DeleteAccount(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.community.AccountService.DeleteAccount", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.ResendVerification(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.community.AccountService.ResendVerification", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.CompleteVerification(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.community.AccountService.CompleteVerification", in, next)
		}
	}

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

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

	return message, err
}

func (i *AccountServiceInterceptor) 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.community.AccountService.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 *AccountServiceInterceptor) 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.community.AccountService.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 *AccountServiceInterceptor) ConfigureActiveSubscription(ctx context.Context, in *ConfigureActiveSubscriptionInput, opts ...grpc.CallOption) (*ConfigureActiveSubscriptionOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*ConfigureActiveSubscriptionInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *ConfigureActiveSubscriptionInput, got %T", in))
		}

		return i.client.ConfigureActiveSubscription(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.community.AccountService.ConfigureActiveSubscription", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.DescribeActiveSubscription(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.community.AccountService.DescribeActiveSubscription", in, next)
		}
	}

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

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

	return message, err
}