content_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 content

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

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

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

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

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

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

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

// RegisterContentServiceHttpHandlers adds handlers for for ContentServiceClient
// This constructor creates http.Handler, the actual implementation might change at any moment
func RegisterContentServiceHttpHandlers(router *mux.Router, prefix string, cli ContentServiceClient) {
	router.Handle(prefix+"/content/fragments/{fragment_id}", _ContentService_DescribeFragment_Rule0(cli)).
		Methods("GET").
		Name("eolymp.content.ContentService.DescribeFragment")
	router.Handle(prefix+"/content/fragments", _ContentService_ListFragments_Rule0(cli)).
		Methods("GET").
		Name("eolymp.content.ContentService.ListFragments")
	router.Handle(prefix+"/content/fragments", _ContentService_CreateFragment_Rule0(cli)).
		Methods("POST").
		Name("eolymp.content.ContentService.CreateFragment")
	router.Handle(prefix+"/content/fragments/{fragment_id}", _ContentService_UpdateFragment_Rule0(cli)).
		Methods("PUT").
		Name("eolymp.content.ContentService.UpdateFragment")
	router.Handle(prefix+"/content/fragments/{fragment_id}", _ContentService_DeleteFragment_Rule0(cli)).
		Methods("DELETE").
		Name("eolymp.content.ContentService.DeleteFragment")
	router.Handle(prefix+"/content/fragments/{fragment_id}/variants/{variant_id}", _ContentService_DescribeVariant_Rule0(cli)).
		Methods("GET").
		Name("eolymp.content.ContentService.DescribeVariant")
	router.Handle(prefix+"/content/fragments/{fragment_id}/variants", _ContentService_ListVariants_Rule0(cli)).
		Methods("GET").
		Name("eolymp.content.ContentService.ListVariants")
	router.Handle(prefix+"/content/fragments/{fragment_id}/variants", _ContentService_CreateVariant_Rule0(cli)).
		Methods("POST").
		Name("eolymp.content.ContentService.CreateVariant")
	router.Handle(prefix+"/content/fragments/{fragment_id}/variants/{variant_id}", _ContentService_UpdateVariant_Rule0(cli)).
		Methods("PUT").
		Name("eolymp.content.ContentService.UpdateVariant")
	router.Handle(prefix+"/content/fragments/{fragment_id}/variants/{variant_id}", _ContentService_DeleteVariant_Rule0(cli)).
		Methods("DELETE").
		Name("eolymp.content.ContentService.DeleteVariant")
	router.Handle(prefix+"/content/path", _ContentService_DescribePath_Rule0(cli)).
		Methods("GET").
		Name("eolymp.content.ContentService.DescribePath")
	router.Handle(prefix+"/content/parents", _ContentService_ListParents_Rule0(cli)).
		Methods("GET").
		Name("eolymp.content.ContentService.ListParents")
}

func _ContentService_DescribeFragment_Rule0(cli ContentServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &DescribeFragmentInput{}

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

		vars := mux.Vars(r)
		in.FragmentId = vars["fragment_id"]

		var header, trailer metadata.MD

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

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

func _ContentService_ListFragments_Rule0(cli ContentServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &ListFragmentsInput{}

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

		var header, trailer metadata.MD

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

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

func _ContentService_CreateFragment_Rule0(cli ContentServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &CreateFragmentInput{}

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

		var header, trailer metadata.MD

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

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

func _ContentService_UpdateFragment_Rule0(cli ContentServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &UpdateFragmentInput{}

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

		vars := mux.Vars(r)
		in.FragmentId = vars["fragment_id"]

		var header, trailer metadata.MD

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

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

func _ContentService_DeleteFragment_Rule0(cli ContentServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &DeleteFragmentInput{}

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

		vars := mux.Vars(r)
		in.FragmentId = vars["fragment_id"]

		var header, trailer metadata.MD

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

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

func _ContentService_DescribeVariant_Rule0(cli ContentServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &DescribeVariantInput{}

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

		vars := mux.Vars(r)
		in.FragmentId = vars["fragment_id"]
		in.VariantId = vars["variant_id"]

		var header, trailer metadata.MD

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

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

func _ContentService_ListVariants_Rule0(cli ContentServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &ListVariantsInput{}

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

		vars := mux.Vars(r)
		in.FragmentId = vars["fragment_id"]

		var header, trailer metadata.MD

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

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

func _ContentService_CreateVariant_Rule0(cli ContentServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &CreateVariantInput{}

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

		vars := mux.Vars(r)
		in.FragmentId = vars["fragment_id"]

		var header, trailer metadata.MD

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

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

func _ContentService_UpdateVariant_Rule0(cli ContentServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &UpdateVariantInput{}

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

		vars := mux.Vars(r)
		in.FragmentId = vars["fragment_id"]
		in.VariantId = vars["variant_id"]

		var header, trailer metadata.MD

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

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

func _ContentService_DeleteVariant_Rule0(cli ContentServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &DeleteVariantInput{}

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

		vars := mux.Vars(r)
		in.FragmentId = vars["fragment_id"]
		in.VariantId = vars["variant_id"]

		var header, trailer metadata.MD

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

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

func _ContentService_DescribePath_Rule0(cli ContentServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &DescribePathInput{}

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

		var header, trailer metadata.MD

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

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

func _ContentService_ListParents_Rule0(cli ContentServiceClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &ListParentsInput{}

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

		var header, trailer metadata.MD

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

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

type _ContentServiceHandler = func(ctx context.Context, in proto.Message) (proto.Message, error)
type _ContentServiceMiddleware = func(ctx context.Context, method string, in proto.Message, handler _ContentServiceHandler) (out proto.Message, err error)
type ContentServiceInterceptor struct {
	middleware []_ContentServiceMiddleware
	client     ContentServiceClient
}

// NewContentServiceInterceptor constructs additional middleware for a server based on annotations in proto files
func NewContentServiceInterceptor(cli ContentServiceClient, middleware ..._ContentServiceMiddleware) *ContentServiceInterceptor {
	return &ContentServiceInterceptor{client: cli, middleware: middleware}
}

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

		return i.client.DescribeFragment(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.content.ContentService.DescribeFragment", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.ListFragments(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.content.ContentService.ListFragments", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.CreateFragment(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.content.ContentService.CreateFragment", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.UpdateFragment(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.content.ContentService.UpdateFragment", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.DeleteFragment(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.content.ContentService.DeleteFragment", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.DescribeVariant(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.content.ContentService.DescribeVariant", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.ListVariants(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.content.ContentService.ListVariants", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.CreateVariant(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.content.ContentService.CreateVariant", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.UpdateVariant(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.content.ContentService.UpdateVariant", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.DeleteVariant(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.content.ContentService.DeleteVariant", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.DescribePath(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.content.ContentService.DescribePath", in, next)
		}
	}

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

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

	return message, err
}

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

		return i.client.ListParents(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.content.ContentService.ListParents", in, next)
		}
	}

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

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

	return message, err
}