enum_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 taxonomy

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

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

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

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

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

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

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

// RegisterEnumServiceHttpHandlers adds handlers for for EnumServiceClient
// This constructor creates http.Handler, the actual implementation might change at any moment
func RegisterEnumServiceHttpHandlers(router *mux.Router, prefix string, cli EnumServiceClient) {
	router.Handle(prefix+"/enums", _EnumService_CreateEnum_Rule0(cli)).
		Methods("POST").
		Name("eolymp.taxonomy.EnumService.CreateEnum")
	router.Handle(prefix+"/enums/{enum_id}", _EnumService_DeleteEnum_Rule0(cli)).
		Methods("DELETE").
		Name("eolymp.taxonomy.EnumService.DeleteEnum")
	router.Handle(prefix+"/enums/{enum_id}", _EnumService_UpdateEnum_Rule0(cli)).
		Methods("PUT").
		Name("eolymp.taxonomy.EnumService.UpdateEnum")
	router.Handle(prefix+"/enums/{enum_id}", _EnumService_DescribeEnum_Rule0(cli)).
		Methods("GET").
		Name("eolymp.taxonomy.EnumService.DescribeEnum")
	router.Handle(prefix+"/enums", _EnumService_ListEnums_Rule0(cli)).
		Methods("GET").
		Name("eolymp.taxonomy.EnumService.ListEnums")
	router.Handle(prefix+"/enums/{enum_id}/items", _EnumService_CreateValue_Rule0(cli)).
		Methods("POST").
		Name("eolymp.taxonomy.EnumService.CreateValue")
	router.Handle(prefix+"/enums/{enum_id}/values/{value_id}", _EnumService_DeleteValue_Rule0(cli)).
		Methods("DELETE").
		Name("eolymp.taxonomy.EnumService.DeleteValue")
	router.Handle(prefix+"/enums/{enum_id}/values/{value_id}", _EnumService_UpdateValue_Rule0(cli)).
		Methods("PUT").
		Name("eolymp.taxonomy.EnumService.UpdateValue")
	router.Handle(prefix+"/enums/{enum_id}/values/{value_id}", _EnumService_DescribeValue_Rule0(cli)).
		Methods("GET").
		Name("eolymp.taxonomy.EnumService.DescribeValue")
	router.Handle(prefix+"/enums/{enum_id}/items", _EnumService_ListValues_Rule0(cli)).
		Methods("GET").
		Name("eolymp.taxonomy.EnumService.ListValues")
	router.Handle(prefix+"/enums/{enum_id}/values/{value_id}/translations/{locale}", _EnumService_TranslateValue_Rule0(cli)).
		Methods("PUT").
		Name("eolymp.taxonomy.EnumService.TranslateValue")
	router.Handle(prefix+"/enums/{enum_id}/values/{value_id}/translations/{locale}", _EnumService_DeleteTranslation_Rule0(cli)).
		Methods("DELETE").
		Name("eolymp.taxonomy.EnumService.DeleteTranslation")
	router.Handle(prefix+"/enums/{enum_id}/values/{value_id}/translations", _EnumService_ListTranslations_Rule0(cli)).
		Methods("DELETE").
		Name("eolymp.taxonomy.EnumService.ListTranslations")
}

func _EnumService_CreateEnum_Rule0(cli EnumServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &CreateEnumInput{}

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

		var header, trailer metadata.MD

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

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

func _EnumService_DeleteEnum_Rule0(cli EnumServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &DeleteEnumInput{}

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

		vars := mux.Vars(r)
		in.EnumId = vars["enum_id"]

		var header, trailer metadata.MD

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

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

func _EnumService_UpdateEnum_Rule0(cli EnumServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &UpdateEnumInput{}

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

		vars := mux.Vars(r)
		in.EnumId = vars["enum_id"]

		var header, trailer metadata.MD

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

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

func _EnumService_DescribeEnum_Rule0(cli EnumServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &DescribeEnumInput{}

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

		vars := mux.Vars(r)
		in.EnumId = vars["enum_id"]

		var header, trailer metadata.MD

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

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

func _EnumService_ListEnums_Rule0(cli EnumServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &ListEnumsInput{}

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

		var header, trailer metadata.MD

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

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

func _EnumService_CreateValue_Rule0(cli EnumServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &CreateValueInput{}

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

		vars := mux.Vars(r)
		in.EnumId = vars["enum_id"]

		var header, trailer metadata.MD

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

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

func _EnumService_DeleteValue_Rule0(cli EnumServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &DeleteValueInput{}

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

		vars := mux.Vars(r)
		in.EnumId = vars["enum_id"]
		in.ValueId = vars["value_id"]

		var header, trailer metadata.MD

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

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

func _EnumService_UpdateValue_Rule0(cli EnumServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &UpdateValueInput{}

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

		vars := mux.Vars(r)
		in.EnumId = vars["enum_id"]
		in.ValueId = vars["value_id"]

		var header, trailer metadata.MD

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

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

func _EnumService_DescribeValue_Rule0(cli EnumServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &DescribeValueInput{}

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

		vars := mux.Vars(r)
		in.EnumId = vars["enum_id"]
		in.ValueId = vars["value_id"]

		var header, trailer metadata.MD

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

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

func _EnumService_ListValues_Rule0(cli EnumServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &ListValuesInput{}

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

		vars := mux.Vars(r)
		in.EnumId = vars["enum_id"]

		var header, trailer metadata.MD

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

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

func _EnumService_TranslateValue_Rule0(cli EnumServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &TranslateValueInput{}

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

		vars := mux.Vars(r)
		in.EnumId = vars["enum_id"]
		in.ValueId = vars["value_id"]
		in.Locale = vars["locale"]

		var header, trailer metadata.MD

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

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

func _EnumService_DeleteTranslation_Rule0(cli EnumServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &DeleteTranslationInput{}

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

		vars := mux.Vars(r)
		in.EnumId = vars["enum_id"]
		in.ValueId = vars["value_id"]
		in.Locale = vars["locale"]

		var header, trailer metadata.MD

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

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

func _EnumService_ListTranslations_Rule0(cli EnumServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &ListTranslationsInput{}

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

		vars := mux.Vars(r)
		in.EnumId = vars["enum_id"]
		in.ValueId = vars["value_id"]

		var header, trailer metadata.MD

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

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

type _EnumServiceHandler = func(ctx context.Context, in proto.Message) (proto.Message, error)
type _EnumServiceMiddleware = func(ctx context.Context, method string, in proto.Message, handler _EnumServiceHandler) (out proto.Message, err error)
type EnumServiceInterceptor struct {
	middleware []_EnumServiceMiddleware
	client     EnumServiceClient
}

// NewEnumServiceInterceptor constructs additional middleware for a server based on annotations in proto files
func NewEnumServiceInterceptor(cli EnumServiceClient, middleware ..._EnumServiceMiddleware) *EnumServiceInterceptor {
	return &EnumServiceInterceptor{client: cli, middleware: middleware}
}

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

		return i.client.CreateEnum(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.taxonomy.EnumService.CreateEnum", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.DeleteEnum(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.taxonomy.EnumService.DeleteEnum", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.UpdateEnum(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.taxonomy.EnumService.UpdateEnum", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.DescribeEnum(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.taxonomy.EnumService.DescribeEnum", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.ListEnums(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.taxonomy.EnumService.ListEnums", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.CreateValue(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.taxonomy.EnumService.CreateValue", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.DeleteValue(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.taxonomy.EnumService.DeleteValue", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.UpdateValue(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.taxonomy.EnumService.UpdateValue", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.DescribeValue(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.taxonomy.EnumService.DescribeValue", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.ListValues(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.taxonomy.EnumService.ListValues", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.TranslateValue(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.taxonomy.EnumService.TranslateValue", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.DeleteTranslation(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.taxonomy.EnumService.DeleteTranslation", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.ListTranslations(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.taxonomy.EnumService.ListTranslations", in, next)
		}
	}

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

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

	return message, err
}