// Code generated by protoc-gen-twirp v8.1.3, DO NOT EDIT.
// source: spec/proto/kv.proto

package protocol

import context "context"
import fmt "fmt"
import http "net/http"
import io "io"
import json "encoding/json"
import strconv "strconv"
import strings "strings"

import protojson "google.golang.org/protobuf/encoding/protojson"
import twirp "github.com/twitchtv/twirp"
import ctxsetters "github.com/twitchtv/twirp/ctxsetters"

// Version compatibility assertion.
// If the constant is not defined in the package, that likely means
// the package needs to be updated to work with this generated code.
// See https://twitchtv.github.io/twirp/docs/version_matrix.html
const _ = twirp.TwirpPackageMinVersion_8_1_0

// ===================
// KVService Interface
// ===================

type KVService interface {
	Put(context.Context, *SimpleRequest) (*SimpleResponse, error)

	Get(context.Context, *SimpleRequest) (*SimpleResponse, error)

	Delete(context.Context, *SimpleRequest) (*SimpleResponse, error)

	Append(context.Context, *PrefixRequest) (*PrefixResponse, error)

	List(context.Context, *PrefixRequest) (*PrefixResponse, error)

	Contains(context.Context, *PrefixRequest) (*PrefixResponse, error)

	Remove(context.Context, *PrefixRequest) (*PrefixResponse, error)

	Acquire(context.Context, *LeaseRequest) (*LeaseResponse, error)

	Renew(context.Context, *LeaseRequest) (*LeaseResponse, error)

	Release(context.Context, *LeaseRequest) (*LeaseResponse, error)

	Import(context.Context, *ImportRequest) (*ImportResponse, error)

	ListKeys(context.Context, *ListKeysRequest) (*ListKeysResponse, error)
}

// =========================
// KVService Protobuf Client
// =========================

type kVServiceProtobufClient struct {
	client      HTTPClient
	urls        [12]string
	interceptor twirp.Interceptor
	opts        twirp.ClientOptions
}

// NewKVServiceProtobufClient creates a Protobuf client that implements the KVService interface.
// It communicates using Protobuf and can be configured with a custom HTTPClient.
func NewKVServiceProtobufClient(baseURL string, client HTTPClient, opts ...twirp.ClientOption) KVService {
	if c, ok := client.(*http.Client); ok {
		client = withoutRedirects(c)
	}

	clientOpts := twirp.ClientOptions{}
	for _, o := range opts {
		o(&clientOpts)
	}

	// Using ReadOpt allows backwards and forwards compatibility with new options in the future
	literalURLs := false
	_ = clientOpts.ReadOpt("literalURLs", &literalURLs)
	var pathPrefix string
	if ok := clientOpts.ReadOpt("pathPrefix", &pathPrefix); !ok {
		pathPrefix = "/twirp" // default prefix
	}

	// Build method URLs: <baseURL>[<prefix>]/<package>.<Service>/<Method>
	serviceURL := sanitizeBaseURL(baseURL)
	serviceURL += baseServicePath(pathPrefix, "protocol", "KVService")
	urls := [12]string{
		serviceURL + "Put",
		serviceURL + "Get",
		serviceURL + "Delete",
		serviceURL + "Append",
		serviceURL + "List",
		serviceURL + "Contains",
		serviceURL + "Remove",
		serviceURL + "Acquire",
		serviceURL + "Renew",
		serviceURL + "Release",
		serviceURL + "Import",
		serviceURL + "ListKeys",
	}

	return &kVServiceProtobufClient{
		client:      client,
		urls:        urls,
		interceptor: twirp.ChainInterceptors(clientOpts.Interceptors...),
		opts:        clientOpts,
	}
}

func (c *kVServiceProtobufClient) Put(ctx context.Context, in *SimpleRequest) (*SimpleResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "KVService")
	ctx = ctxsetters.WithMethodName(ctx, "Put")
	caller := c.callPut
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *SimpleRequest) (*SimpleResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimpleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimpleRequest) when calling interceptor")
					}
					return c.callPut(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimpleResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimpleResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *kVServiceProtobufClient) callPut(ctx context.Context, in *SimpleRequest) (*SimpleResponse, error) {
	out := new(SimpleResponse)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[0], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *kVServiceProtobufClient) Get(ctx context.Context, in *SimpleRequest) (*SimpleResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "KVService")
	ctx = ctxsetters.WithMethodName(ctx, "Get")
	caller := c.callGet
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *SimpleRequest) (*SimpleResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimpleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimpleRequest) when calling interceptor")
					}
					return c.callGet(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimpleResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimpleResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *kVServiceProtobufClient) callGet(ctx context.Context, in *SimpleRequest) (*SimpleResponse, error) {
	out := new(SimpleResponse)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[1], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *kVServiceProtobufClient) Delete(ctx context.Context, in *SimpleRequest) (*SimpleResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "KVService")
	ctx = ctxsetters.WithMethodName(ctx, "Delete")
	caller := c.callDelete
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *SimpleRequest) (*SimpleResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimpleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimpleRequest) when calling interceptor")
					}
					return c.callDelete(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimpleResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimpleResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *kVServiceProtobufClient) callDelete(ctx context.Context, in *SimpleRequest) (*SimpleResponse, error) {
	out := new(SimpleResponse)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[2], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *kVServiceProtobufClient) Append(ctx context.Context, in *PrefixRequest) (*PrefixResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "KVService")
	ctx = ctxsetters.WithMethodName(ctx, "Append")
	caller := c.callAppend
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *PrefixRequest) (*PrefixResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*PrefixRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*PrefixRequest) when calling interceptor")
					}
					return c.callAppend(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*PrefixResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*PrefixResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *kVServiceProtobufClient) callAppend(ctx context.Context, in *PrefixRequest) (*PrefixResponse, error) {
	out := new(PrefixResponse)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[3], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *kVServiceProtobufClient) List(ctx context.Context, in *PrefixRequest) (*PrefixResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "KVService")
	ctx = ctxsetters.WithMethodName(ctx, "List")
	caller := c.callList
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *PrefixRequest) (*PrefixResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*PrefixRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*PrefixRequest) when calling interceptor")
					}
					return c.callList(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*PrefixResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*PrefixResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *kVServiceProtobufClient) callList(ctx context.Context, in *PrefixRequest) (*PrefixResponse, error) {
	out := new(PrefixResponse)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[4], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *kVServiceProtobufClient) Contains(ctx context.Context, in *PrefixRequest) (*PrefixResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "KVService")
	ctx = ctxsetters.WithMethodName(ctx, "Contains")
	caller := c.callContains
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *PrefixRequest) (*PrefixResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*PrefixRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*PrefixRequest) when calling interceptor")
					}
					return c.callContains(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*PrefixResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*PrefixResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *kVServiceProtobufClient) callContains(ctx context.Context, in *PrefixRequest) (*PrefixResponse, error) {
	out := new(PrefixResponse)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[5], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *kVServiceProtobufClient) Remove(ctx context.Context, in *PrefixRequest) (*PrefixResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "KVService")
	ctx = ctxsetters.WithMethodName(ctx, "Remove")
	caller := c.callRemove
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *PrefixRequest) (*PrefixResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*PrefixRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*PrefixRequest) when calling interceptor")
					}
					return c.callRemove(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*PrefixResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*PrefixResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *kVServiceProtobufClient) callRemove(ctx context.Context, in *PrefixRequest) (*PrefixResponse, error) {
	out := new(PrefixResponse)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[6], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *kVServiceProtobufClient) Acquire(ctx context.Context, in *LeaseRequest) (*LeaseResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "KVService")
	ctx = ctxsetters.WithMethodName(ctx, "Acquire")
	caller := c.callAcquire
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *LeaseRequest) (*LeaseResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*LeaseRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*LeaseRequest) when calling interceptor")
					}
					return c.callAcquire(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*LeaseResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*LeaseResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *kVServiceProtobufClient) callAcquire(ctx context.Context, in *LeaseRequest) (*LeaseResponse, error) {
	out := new(LeaseResponse)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[7], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *kVServiceProtobufClient) Renew(ctx context.Context, in *LeaseRequest) (*LeaseResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "KVService")
	ctx = ctxsetters.WithMethodName(ctx, "Renew")
	caller := c.callRenew
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *LeaseRequest) (*LeaseResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*LeaseRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*LeaseRequest) when calling interceptor")
					}
					return c.callRenew(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*LeaseResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*LeaseResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *kVServiceProtobufClient) callRenew(ctx context.Context, in *LeaseRequest) (*LeaseResponse, error) {
	out := new(LeaseResponse)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[8], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *kVServiceProtobufClient) Release(ctx context.Context, in *LeaseRequest) (*LeaseResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "KVService")
	ctx = ctxsetters.WithMethodName(ctx, "Release")
	caller := c.callRelease
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *LeaseRequest) (*LeaseResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*LeaseRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*LeaseRequest) when calling interceptor")
					}
					return c.callRelease(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*LeaseResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*LeaseResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *kVServiceProtobufClient) callRelease(ctx context.Context, in *LeaseRequest) (*LeaseResponse, error) {
	out := new(LeaseResponse)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[9], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *kVServiceProtobufClient) Import(ctx context.Context, in *ImportRequest) (*ImportResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "KVService")
	ctx = ctxsetters.WithMethodName(ctx, "Import")
	caller := c.callImport
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *ImportRequest) (*ImportResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ImportRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ImportRequest) when calling interceptor")
					}
					return c.callImport(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ImportResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ImportResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *kVServiceProtobufClient) callImport(ctx context.Context, in *ImportRequest) (*ImportResponse, error) {
	out := new(ImportResponse)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[10], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *kVServiceProtobufClient) ListKeys(ctx context.Context, in *ListKeysRequest) (*ListKeysResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "KVService")
	ctx = ctxsetters.WithMethodName(ctx, "ListKeys")
	caller := c.callListKeys
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *ListKeysRequest) (*ListKeysResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ListKeysRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ListKeysRequest) when calling interceptor")
					}
					return c.callListKeys(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ListKeysResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ListKeysResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *kVServiceProtobufClient) callListKeys(ctx context.Context, in *ListKeysRequest) (*ListKeysResponse, error) {
	out := new(ListKeysResponse)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[11], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

// =====================
// KVService JSON Client
// =====================

type kVServiceJSONClient struct {
	client      HTTPClient
	urls        [12]string
	interceptor twirp.Interceptor
	opts        twirp.ClientOptions
}

// NewKVServiceJSONClient creates a JSON client that implements the KVService interface.
// It communicates using JSON and can be configured with a custom HTTPClient.
func NewKVServiceJSONClient(baseURL string, client HTTPClient, opts ...twirp.ClientOption) KVService {
	if c, ok := client.(*http.Client); ok {
		client = withoutRedirects(c)
	}

	clientOpts := twirp.ClientOptions{}
	for _, o := range opts {
		o(&clientOpts)
	}

	// Using ReadOpt allows backwards and forwards compatibility with new options in the future
	literalURLs := false
	_ = clientOpts.ReadOpt("literalURLs", &literalURLs)
	var pathPrefix string
	if ok := clientOpts.ReadOpt("pathPrefix", &pathPrefix); !ok {
		pathPrefix = "/twirp" // default prefix
	}

	// Build method URLs: <baseURL>[<prefix>]/<package>.<Service>/<Method>
	serviceURL := sanitizeBaseURL(baseURL)
	serviceURL += baseServicePath(pathPrefix, "protocol", "KVService")
	urls := [12]string{
		serviceURL + "Put",
		serviceURL + "Get",
		serviceURL + "Delete",
		serviceURL + "Append",
		serviceURL + "List",
		serviceURL + "Contains",
		serviceURL + "Remove",
		serviceURL + "Acquire",
		serviceURL + "Renew",
		serviceURL + "Release",
		serviceURL + "Import",
		serviceURL + "ListKeys",
	}

	return &kVServiceJSONClient{
		client:      client,
		urls:        urls,
		interceptor: twirp.ChainInterceptors(clientOpts.Interceptors...),
		opts:        clientOpts,
	}
}

func (c *kVServiceJSONClient) Put(ctx context.Context, in *SimpleRequest) (*SimpleResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "KVService")
	ctx = ctxsetters.WithMethodName(ctx, "Put")
	caller := c.callPut
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *SimpleRequest) (*SimpleResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimpleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimpleRequest) when calling interceptor")
					}
					return c.callPut(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimpleResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimpleResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *kVServiceJSONClient) callPut(ctx context.Context, in *SimpleRequest) (*SimpleResponse, error) {
	out := new(SimpleResponse)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[0], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *kVServiceJSONClient) Get(ctx context.Context, in *SimpleRequest) (*SimpleResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "KVService")
	ctx = ctxsetters.WithMethodName(ctx, "Get")
	caller := c.callGet
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *SimpleRequest) (*SimpleResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimpleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimpleRequest) when calling interceptor")
					}
					return c.callGet(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimpleResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimpleResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *kVServiceJSONClient) callGet(ctx context.Context, in *SimpleRequest) (*SimpleResponse, error) {
	out := new(SimpleResponse)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[1], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *kVServiceJSONClient) Delete(ctx context.Context, in *SimpleRequest) (*SimpleResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "KVService")
	ctx = ctxsetters.WithMethodName(ctx, "Delete")
	caller := c.callDelete
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *SimpleRequest) (*SimpleResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimpleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimpleRequest) when calling interceptor")
					}
					return c.callDelete(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimpleResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimpleResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *kVServiceJSONClient) callDelete(ctx context.Context, in *SimpleRequest) (*SimpleResponse, error) {
	out := new(SimpleResponse)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[2], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *kVServiceJSONClient) Append(ctx context.Context, in *PrefixRequest) (*PrefixResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "KVService")
	ctx = ctxsetters.WithMethodName(ctx, "Append")
	caller := c.callAppend
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *PrefixRequest) (*PrefixResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*PrefixRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*PrefixRequest) when calling interceptor")
					}
					return c.callAppend(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*PrefixResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*PrefixResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *kVServiceJSONClient) callAppend(ctx context.Context, in *PrefixRequest) (*PrefixResponse, error) {
	out := new(PrefixResponse)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[3], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *kVServiceJSONClient) List(ctx context.Context, in *PrefixRequest) (*PrefixResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "KVService")
	ctx = ctxsetters.WithMethodName(ctx, "List")
	caller := c.callList
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *PrefixRequest) (*PrefixResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*PrefixRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*PrefixRequest) when calling interceptor")
					}
					return c.callList(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*PrefixResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*PrefixResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *kVServiceJSONClient) callList(ctx context.Context, in *PrefixRequest) (*PrefixResponse, error) {
	out := new(PrefixResponse)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[4], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *kVServiceJSONClient) Contains(ctx context.Context, in *PrefixRequest) (*PrefixResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "KVService")
	ctx = ctxsetters.WithMethodName(ctx, "Contains")
	caller := c.callContains
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *PrefixRequest) (*PrefixResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*PrefixRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*PrefixRequest) when calling interceptor")
					}
					return c.callContains(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*PrefixResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*PrefixResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *kVServiceJSONClient) callContains(ctx context.Context, in *PrefixRequest) (*PrefixResponse, error) {
	out := new(PrefixResponse)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[5], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *kVServiceJSONClient) Remove(ctx context.Context, in *PrefixRequest) (*PrefixResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "KVService")
	ctx = ctxsetters.WithMethodName(ctx, "Remove")
	caller := c.callRemove
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *PrefixRequest) (*PrefixResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*PrefixRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*PrefixRequest) when calling interceptor")
					}
					return c.callRemove(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*PrefixResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*PrefixResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *kVServiceJSONClient) callRemove(ctx context.Context, in *PrefixRequest) (*PrefixResponse, error) {
	out := new(PrefixResponse)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[6], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *kVServiceJSONClient) Acquire(ctx context.Context, in *LeaseRequest) (*LeaseResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "KVService")
	ctx = ctxsetters.WithMethodName(ctx, "Acquire")
	caller := c.callAcquire
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *LeaseRequest) (*LeaseResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*LeaseRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*LeaseRequest) when calling interceptor")
					}
					return c.callAcquire(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*LeaseResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*LeaseResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *kVServiceJSONClient) callAcquire(ctx context.Context, in *LeaseRequest) (*LeaseResponse, error) {
	out := new(LeaseResponse)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[7], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *kVServiceJSONClient) Renew(ctx context.Context, in *LeaseRequest) (*LeaseResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "KVService")
	ctx = ctxsetters.WithMethodName(ctx, "Renew")
	caller := c.callRenew
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *LeaseRequest) (*LeaseResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*LeaseRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*LeaseRequest) when calling interceptor")
					}
					return c.callRenew(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*LeaseResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*LeaseResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *kVServiceJSONClient) callRenew(ctx context.Context, in *LeaseRequest) (*LeaseResponse, error) {
	out := new(LeaseResponse)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[8], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *kVServiceJSONClient) Release(ctx context.Context, in *LeaseRequest) (*LeaseResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "KVService")
	ctx = ctxsetters.WithMethodName(ctx, "Release")
	caller := c.callRelease
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *LeaseRequest) (*LeaseResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*LeaseRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*LeaseRequest) when calling interceptor")
					}
					return c.callRelease(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*LeaseResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*LeaseResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *kVServiceJSONClient) callRelease(ctx context.Context, in *LeaseRequest) (*LeaseResponse, error) {
	out := new(LeaseResponse)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[9], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *kVServiceJSONClient) Import(ctx context.Context, in *ImportRequest) (*ImportResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "KVService")
	ctx = ctxsetters.WithMethodName(ctx, "Import")
	caller := c.callImport
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *ImportRequest) (*ImportResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ImportRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ImportRequest) when calling interceptor")
					}
					return c.callImport(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ImportResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ImportResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *kVServiceJSONClient) callImport(ctx context.Context, in *ImportRequest) (*ImportResponse, error) {
	out := new(ImportResponse)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[10], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *kVServiceJSONClient) ListKeys(ctx context.Context, in *ListKeysRequest) (*ListKeysResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "KVService")
	ctx = ctxsetters.WithMethodName(ctx, "ListKeys")
	caller := c.callListKeys
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *ListKeysRequest) (*ListKeysResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ListKeysRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ListKeysRequest) when calling interceptor")
					}
					return c.callListKeys(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ListKeysResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ListKeysResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *kVServiceJSONClient) callListKeys(ctx context.Context, in *ListKeysRequest) (*ListKeysResponse, error) {
	out := new(ListKeysResponse)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[11], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

// ========================
// KVService Server Handler
// ========================

type kVServiceServer struct {
	KVService
	interceptor      twirp.Interceptor
	hooks            *twirp.ServerHooks
	pathPrefix       string // prefix for routing
	jsonSkipDefaults bool   // do not include unpopulated fields (default values) in the response
	jsonCamelCase    bool   // JSON fields are serialized as lowerCamelCase rather than keeping the original proto names
}

// NewKVServiceServer builds a TwirpServer that can be used as an http.Handler to handle
// HTTP requests that are routed to the right method in the provided svc implementation.
// The opts are twirp.ServerOption modifiers, for example twirp.WithServerHooks(hooks).
func NewKVServiceServer(svc KVService, opts ...interface{}) TwirpServer {
	serverOpts := newServerOpts(opts)

	// Using ReadOpt allows backwards and forwards compatibility with new options in the future
	jsonSkipDefaults := false
	_ = serverOpts.ReadOpt("jsonSkipDefaults", &jsonSkipDefaults)
	jsonCamelCase := false
	_ = serverOpts.ReadOpt("jsonCamelCase", &jsonCamelCase)
	var pathPrefix string
	if ok := serverOpts.ReadOpt("pathPrefix", &pathPrefix); !ok {
		pathPrefix = "/twirp" // default prefix
	}

	return &kVServiceServer{
		KVService:        svc,
		hooks:            serverOpts.Hooks,
		interceptor:      twirp.ChainInterceptors(serverOpts.Interceptors...),
		pathPrefix:       pathPrefix,
		jsonSkipDefaults: jsonSkipDefaults,
		jsonCamelCase:    jsonCamelCase,
	}
}

// writeError writes an HTTP response with a valid Twirp error format, and triggers hooks.
// If err is not a twirp.Error, it will get wrapped with twirp.InternalErrorWith(err)
func (s *kVServiceServer) writeError(ctx context.Context, resp http.ResponseWriter, err error) {
	writeError(ctx, resp, err, s.hooks)
}

// handleRequestBodyError is used to handle error when the twirp server cannot read request
func (s *kVServiceServer) handleRequestBodyError(ctx context.Context, resp http.ResponseWriter, msg string, err error) {
	if context.Canceled == ctx.Err() {
		s.writeError(ctx, resp, twirp.NewError(twirp.Canceled, "failed to read request: context canceled"))
		return
	}
	if context.DeadlineExceeded == ctx.Err() {
		s.writeError(ctx, resp, twirp.NewError(twirp.DeadlineExceeded, "failed to read request: deadline exceeded"))
		return
	}
	s.writeError(ctx, resp, twirp.WrapError(malformedRequestError(msg), err))
}

// KVServicePathPrefix is a convenience constant that may identify URL paths.
// Should be used with caution, it only matches routes generated by Twirp Go clients,
// with the default "/twirp" prefix and default CamelCase service and method names.
// More info: https://twitchtv.github.io/twirp/docs/routing.html
const KVServicePathPrefix = "/twirp/protocol.KVService/"

func (s *kVServiceServer) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
	ctx := req.Context()
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "KVService")
	ctx = ctxsetters.WithResponseWriter(ctx, resp)

	var err error
	ctx, err = callRequestReceived(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	if req.Method != "POST" {
		msg := fmt.Sprintf("unsupported method %q (only POST is allowed)", req.Method)
		s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path))
		return
	}

	// Verify path format: [<prefix>]/<package>.<Service>/<Method>
	prefix, pkgService, method := parseTwirpPath(req.URL.Path)
	if pkgService != "protocol.KVService" {
		msg := fmt.Sprintf("no handler for path %q", req.URL.Path)
		s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path))
		return
	}
	if prefix != s.pathPrefix {
		msg := fmt.Sprintf("invalid path prefix %q, expected %q, on path %q", prefix, s.pathPrefix, req.URL.Path)
		s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path))
		return
	}

	switch method {
	case "Put":
		s.servePut(ctx, resp, req)
		return
	case "Get":
		s.serveGet(ctx, resp, req)
		return
	case "Delete":
		s.serveDelete(ctx, resp, req)
		return
	case "Append":
		s.serveAppend(ctx, resp, req)
		return
	case "List":
		s.serveList(ctx, resp, req)
		return
	case "Contains":
		s.serveContains(ctx, resp, req)
		return
	case "Remove":
		s.serveRemove(ctx, resp, req)
		return
	case "Acquire":
		s.serveAcquire(ctx, resp, req)
		return
	case "Renew":
		s.serveRenew(ctx, resp, req)
		return
	case "Release":
		s.serveRelease(ctx, resp, req)
		return
	case "Import":
		s.serveImport(ctx, resp, req)
		return
	case "ListKeys":
		s.serveListKeys(ctx, resp, req)
		return
	default:
		msg := fmt.Sprintf("no handler for path %q", req.URL.Path)
		s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path))
		return
	}
}

func (s *kVServiceServer) servePut(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.servePutJSON(ctx, resp, req)
	case "application/protobuf":
		s.servePutProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *kVServiceServer) servePutJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "Put")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(SimpleRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.KVService.Put
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *SimpleRequest) (*SimpleResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimpleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimpleRequest) when calling interceptor")
					}
					return s.KVService.Put(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimpleResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimpleResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *SimpleResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *SimpleResponse and nil error while calling Put. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *kVServiceServer) servePutProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "Put")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(SimpleRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.KVService.Put
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *SimpleRequest) (*SimpleResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimpleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimpleRequest) when calling interceptor")
					}
					return s.KVService.Put(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimpleResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimpleResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *SimpleResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *SimpleResponse and nil error while calling Put. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := respContent.MarshalVT()
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *kVServiceServer) serveGet(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveGetJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveGetProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *kVServiceServer) serveGetJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "Get")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(SimpleRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.KVService.Get
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *SimpleRequest) (*SimpleResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimpleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimpleRequest) when calling interceptor")
					}
					return s.KVService.Get(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimpleResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimpleResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *SimpleResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *SimpleResponse and nil error while calling Get. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *kVServiceServer) serveGetProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "Get")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(SimpleRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.KVService.Get
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *SimpleRequest) (*SimpleResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimpleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimpleRequest) when calling interceptor")
					}
					return s.KVService.Get(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimpleResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimpleResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *SimpleResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *SimpleResponse and nil error while calling Get. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := respContent.MarshalVT()
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *kVServiceServer) serveDelete(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveDeleteJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveDeleteProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *kVServiceServer) serveDeleteJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "Delete")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(SimpleRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.KVService.Delete
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *SimpleRequest) (*SimpleResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimpleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimpleRequest) when calling interceptor")
					}
					return s.KVService.Delete(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimpleResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimpleResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *SimpleResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *SimpleResponse and nil error while calling Delete. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *kVServiceServer) serveDeleteProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "Delete")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(SimpleRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.KVService.Delete
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *SimpleRequest) (*SimpleResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimpleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimpleRequest) when calling interceptor")
					}
					return s.KVService.Delete(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimpleResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimpleResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *SimpleResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *SimpleResponse and nil error while calling Delete. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := respContent.MarshalVT()
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *kVServiceServer) serveAppend(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveAppendJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveAppendProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *kVServiceServer) serveAppendJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "Append")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(PrefixRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.KVService.Append
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *PrefixRequest) (*PrefixResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*PrefixRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*PrefixRequest) when calling interceptor")
					}
					return s.KVService.Append(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*PrefixResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*PrefixResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *PrefixResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *PrefixResponse and nil error while calling Append. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *kVServiceServer) serveAppendProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "Append")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(PrefixRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.KVService.Append
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *PrefixRequest) (*PrefixResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*PrefixRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*PrefixRequest) when calling interceptor")
					}
					return s.KVService.Append(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*PrefixResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*PrefixResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *PrefixResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *PrefixResponse and nil error while calling Append. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := respContent.MarshalVT()
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *kVServiceServer) serveList(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveListJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveListProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *kVServiceServer) serveListJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "List")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(PrefixRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.KVService.List
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *PrefixRequest) (*PrefixResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*PrefixRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*PrefixRequest) when calling interceptor")
					}
					return s.KVService.List(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*PrefixResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*PrefixResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *PrefixResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *PrefixResponse and nil error while calling List. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *kVServiceServer) serveListProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "List")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(PrefixRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.KVService.List
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *PrefixRequest) (*PrefixResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*PrefixRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*PrefixRequest) when calling interceptor")
					}
					return s.KVService.List(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*PrefixResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*PrefixResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *PrefixResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *PrefixResponse and nil error while calling List. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := respContent.MarshalVT()
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *kVServiceServer) serveContains(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveContainsJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveContainsProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *kVServiceServer) serveContainsJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "Contains")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(PrefixRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.KVService.Contains
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *PrefixRequest) (*PrefixResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*PrefixRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*PrefixRequest) when calling interceptor")
					}
					return s.KVService.Contains(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*PrefixResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*PrefixResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *PrefixResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *PrefixResponse and nil error while calling Contains. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *kVServiceServer) serveContainsProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "Contains")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(PrefixRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.KVService.Contains
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *PrefixRequest) (*PrefixResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*PrefixRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*PrefixRequest) when calling interceptor")
					}
					return s.KVService.Contains(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*PrefixResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*PrefixResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *PrefixResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *PrefixResponse and nil error while calling Contains. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := respContent.MarshalVT()
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *kVServiceServer) serveRemove(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveRemoveJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveRemoveProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *kVServiceServer) serveRemoveJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "Remove")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(PrefixRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.KVService.Remove
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *PrefixRequest) (*PrefixResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*PrefixRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*PrefixRequest) when calling interceptor")
					}
					return s.KVService.Remove(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*PrefixResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*PrefixResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *PrefixResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *PrefixResponse and nil error while calling Remove. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *kVServiceServer) serveRemoveProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "Remove")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(PrefixRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.KVService.Remove
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *PrefixRequest) (*PrefixResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*PrefixRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*PrefixRequest) when calling interceptor")
					}
					return s.KVService.Remove(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*PrefixResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*PrefixResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *PrefixResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *PrefixResponse and nil error while calling Remove. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := respContent.MarshalVT()
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *kVServiceServer) serveAcquire(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveAcquireJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveAcquireProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *kVServiceServer) serveAcquireJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "Acquire")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(LeaseRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.KVService.Acquire
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *LeaseRequest) (*LeaseResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*LeaseRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*LeaseRequest) when calling interceptor")
					}
					return s.KVService.Acquire(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*LeaseResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*LeaseResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *LeaseResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *LeaseResponse and nil error while calling Acquire. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *kVServiceServer) serveAcquireProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "Acquire")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(LeaseRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.KVService.Acquire
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *LeaseRequest) (*LeaseResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*LeaseRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*LeaseRequest) when calling interceptor")
					}
					return s.KVService.Acquire(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*LeaseResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*LeaseResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *LeaseResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *LeaseResponse and nil error while calling Acquire. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := respContent.MarshalVT()
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *kVServiceServer) serveRenew(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveRenewJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveRenewProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *kVServiceServer) serveRenewJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "Renew")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(LeaseRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.KVService.Renew
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *LeaseRequest) (*LeaseResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*LeaseRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*LeaseRequest) when calling interceptor")
					}
					return s.KVService.Renew(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*LeaseResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*LeaseResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *LeaseResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *LeaseResponse and nil error while calling Renew. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *kVServiceServer) serveRenewProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "Renew")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(LeaseRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.KVService.Renew
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *LeaseRequest) (*LeaseResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*LeaseRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*LeaseRequest) when calling interceptor")
					}
					return s.KVService.Renew(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*LeaseResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*LeaseResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *LeaseResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *LeaseResponse and nil error while calling Renew. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := respContent.MarshalVT()
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *kVServiceServer) serveRelease(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveReleaseJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveReleaseProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *kVServiceServer) serveReleaseJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "Release")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(LeaseRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.KVService.Release
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *LeaseRequest) (*LeaseResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*LeaseRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*LeaseRequest) when calling interceptor")
					}
					return s.KVService.Release(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*LeaseResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*LeaseResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *LeaseResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *LeaseResponse and nil error while calling Release. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *kVServiceServer) serveReleaseProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "Release")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(LeaseRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.KVService.Release
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *LeaseRequest) (*LeaseResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*LeaseRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*LeaseRequest) when calling interceptor")
					}
					return s.KVService.Release(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*LeaseResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*LeaseResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *LeaseResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *LeaseResponse and nil error while calling Release. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := respContent.MarshalVT()
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *kVServiceServer) serveImport(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveImportJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveImportProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *kVServiceServer) serveImportJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "Import")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(ImportRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.KVService.Import
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *ImportRequest) (*ImportResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ImportRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ImportRequest) when calling interceptor")
					}
					return s.KVService.Import(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ImportResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ImportResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *ImportResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *ImportResponse and nil error while calling Import. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *kVServiceServer) serveImportProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "Import")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(ImportRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.KVService.Import
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *ImportRequest) (*ImportResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ImportRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ImportRequest) when calling interceptor")
					}
					return s.KVService.Import(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ImportResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ImportResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *ImportResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *ImportResponse and nil error while calling Import. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := respContent.MarshalVT()
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *kVServiceServer) serveListKeys(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveListKeysJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveListKeysProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *kVServiceServer) serveListKeysJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "ListKeys")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(ListKeysRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.KVService.ListKeys
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *ListKeysRequest) (*ListKeysResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ListKeysRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ListKeysRequest) when calling interceptor")
					}
					return s.KVService.ListKeys(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ListKeysResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ListKeysResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *ListKeysResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *ListKeysResponse and nil error while calling ListKeys. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *kVServiceServer) serveListKeysProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "ListKeys")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(ListKeysRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.KVService.ListKeys
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *ListKeysRequest) (*ListKeysResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ListKeysRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ListKeysRequest) when calling interceptor")
					}
					return s.KVService.ListKeys(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ListKeysResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ListKeysResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *ListKeysResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *ListKeysResponse and nil error while calling ListKeys. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := respContent.MarshalVT()
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *kVServiceServer) ServiceDescriptor() ([]byte, int) {
	return twirpFileDescriptor3, 0
}

func (s *kVServiceServer) ProtocGenTwirpVersion() string {
	return "v8.1.3"
}

// PathPrefix returns the base service path, in the form: "/<prefix>/<package>.<Service>/"
// that is everything in a Twirp route except for the <Method>. This can be used for routing,
// for example to identify the requests that are targeted to this service in a mux.
func (s *kVServiceServer) PathPrefix() string {
	return baseServicePath(s.pathPrefix, "protocol", "KVService")
}

var twirpFileDescriptor3 = []byte{
	// 725 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x55, 0xdd, 0x4e, 0xdb, 0x4c,
	0x10, 0xc5, 0xe4, 0x87, 0x64, 0xf2, 0x83, 0xb5, 0x1f, 0x82, 0x10, 0xf4, 0xb5, 0xc8, 0x52, 0x81,
	0x96, 0xca, 0x91, 0x52, 0xa9, 0xa5, 0x20, 0x2a, 0x05, 0x48, 0x0b, 0x4a, 0x4a, 0x53, 0x87, 0xd2,
	0xaa, 0x37, 0x91, 0x31, 0x43, 0x6a, 0xc5, 0xf1, 0x1a, 0xef, 0x26, 0x90, 0x37, 0x68, 0x2f, 0xaa,
	0xbe, 0x63, 0x9f, 0xa4, 0xf2, 0xae, 0x9d, 0x38, 0x05, 0xa9, 0x22, 0x57, 0xd9, 0x33, 0x33, 0x67,
	0x66, 0xe7, 0xec, 0x4c, 0x0c, 0xff, 0x31, 0x0f, 0xad, 0x8a, 0xe7, 0x53, 0x4e, 0x2b, 0xbd, 0xa1,
	0x2e, 0x0e, 0x24, 0x23, 0x7e, 0x2c, 0xea, 0x94, 0x1f, 0x75, 0x29, 0xed, 0x3a, 0x28, 0x03, 0x2e,
	0x06, 0x57, 0x95, 0xcb, 0x81, 0x6f, 0x72, 0x9b, 0xba, 0x32, 0x52, 0x7b, 0x05, 0x85, 0xb6, 0xdd,
	0xf7, 0x1c, 0x34, 0xf0, 0x7a, 0x80, 0x8c, 0x13, 0x15, 0x12, 0x3d, 0x1c, 0x95, 0x94, 0x75, 0x65,
	0x2b, 0x6f, 0x04, 0x47, 0xb2, 0x04, 0xa9, 0xa1, 0xe9, 0x0c, 0xb0, 0x34, 0x2f, 0x6c, 0x12, 0x68,
	0x1b, 0x50, 0x8c, 0x88, 0xcc, 0xa3, 0x2e, 0xc3, 0x49, 0x9c, 0x12, 0x8f, 0xdb, 0x87, 0x42, 0xcb,
	0xc7, 0x2b, 0xfb, 0x36, 0x2a, 0xb0, 0x0c, 0x69, 0x4f, 0x18, 0xc2, 0xb8, 0x10, 0x05, 0x74, 0xeb,
	0x9b, 0xed, 0x5c, 0x46, 0x65, 0x04, 0xd0, 0x8e, 0xa0, 0x18, 0xd1, 0xc3, 0x32, 0x65, 0xc8, 0x08,
	0x97, 0x8f, 0x6e, 0x49, 0x59, 0x4f, 0x6c, 0xe5, 0x8d, 0x31, 0x0e, 0x72, 0xe3, 0xad, 0xcd, 0x38,
	0x13, 0x49, 0x32, 0x46, 0x88, 0xb4, 0x9f, 0x0a, 0xe4, 0x9b, 0x68, 0xb2, 0x71, 0x97, 0x4b, 0x90,
	0x72, 0x02, 0x1c, 0xdd, 0x55, 0x00, 0xb2, 0x06, 0x59, 0x17, 0x6f, 0x3a, 0x9c, 0xf6, 0xd0, 0x15,
	0x19, 0x92, 0x46, 0xc6, 0xc5, 0x9b, 0xb3, 0x00, 0x93, 0xff, 0x01, 0x3c, 0x1f, 0x87, 0xa1, 0x37,
	0x21, 0xbc, 0xd9, 0xc0, 0x22, 0xdd, 0xdb, 0x90, 0xe0, 0xdc, 0x29, 0xa5, 0xd6, 0x95, 0xad, 0x5c,
	0x75, 0x55, 0x97, 0xb2, 0xeb, 0x91, 0xec, 0xfa, 0x51, 0x28, 0xbb, 0x11, 0x44, 0x69, 0x4f, 0xa0,
	0x10, 0x5e, 0x67, 0xa2, 0x9d, 0xcc, 0xab, 0x88, 0xbc, 0x12, 0x68, 0xbf, 0x14, 0x80, 0xc6, 0xf9,
	0x99, 0x6f, 0xba, 0xec, 0x0a, 0x7d, 0xb2, 0x01, 0x79, 0x26, 0x24, 0xef, 0xc4, 0x74, 0x3e, 0x9e,
	0x33, 0x72, 0xd2, 0x7a, 0x1e, 0x18, 0xbf, 0x2b, 0x0a, 0xd9, 0x84, 0x45, 0xa9, 0x69, 0x67, 0x2c,
	0xd4, 0xbc, 0x10, 0xaa, 0x28, 0xcd, 0x87, 0x91, 0x5c, 0x8f, 0x21, 0x27, 0x1a, 0x9f, 0xea, 0x09,
	0x84, 0x49, 0x34, 0x75, 0xb0, 0x08, 0x85, 0x4e, 0xbc, 0xa4, 0xf6, 0x11, 0x0a, 0x27, 0x7d, 0x8f,
	0xfa, 0x3c, 0x12, 0x92, 0x40, 0xb2, 0x87, 0x23, 0x16, 0xbe, 0x84, 0x38, 0x93, 0xe7, 0x90, 0x16,
	0xd1, 0x4c, 0x94, 0xcd, 0x55, 0x97, 0xf4, 0x68, 0x1c, 0xf5, 0x49, 0x37, 0x46, 0x18, 0xa3, 0xa9,
	0x50, 0x8c, 0x52, 0x4a, 0x31, 0xb4, 0xa7, 0xb0, 0xd8, 0xb4, 0x19, 0x6f, 0xe0, 0x88, 0xfd, 0x63,
	0x68, 0xb4, 0x1f, 0x0a, 0xe4, 0x1b, 0x38, 0x3a, 0xa4, 0x7d, 0x8f, 0x32, 0x9b, 0xe3, 0x3d, 0xe3,
	0x5b, 0x81, 0x24, 0x1f, 0x79, 0x72, 0x7a, 0x8b, 0xd5, 0xb5, 0xd8, 0x5d, 0x62, 0x3c, 0xfd, 0x6c,
	0xe4, 0xa1, 0x21, 0x02, 0xb5, 0x97, 0x90, 0x0c, 0x10, 0xc9, 0xc1, 0xc2, 0xa7, 0xd3, 0xc6, 0xe9,
	0x87, 0xcf, 0xa7, 0xea, 0x1c, 0x01, 0x48, 0xb7, 0x4f, 0xde, 0xb7, 0x9a, 0x75, 0x55, 0x09, 0xce,
	0x2d, 0xa3, 0xfe, 0xf6, 0xe4, 0x8b, 0x3a, 0x4f, 0xb2, 0x90, 0x6a, 0xd6, 0x6b, 0xed, 0xba, 0x9a,
	0xd0, 0xde, 0x80, 0x3a, 0xb9, 0x76, 0xf8, 0xae, 0xcf, 0x62, 0xf2, 0xe4, 0xaa, 0xcb, 0xf7, 0x17,
	0x97, 0xb2, 0x55, 0x7f, 0xa7, 0x20, 0xdb, 0x38, 0x6f, 0xa3, 0x3f, 0xb4, 0x2d, 0x24, 0x3b, 0x90,
	0x68, 0x0d, 0x38, 0x59, 0x99, 0x50, 0xa6, 0xf6, 0xb4, 0x5c, 0xba, 0xeb, 0x08, 0x6b, 0xee, 0x40,
	0xe2, 0x1d, 0xce, 0xc4, 0xdc, 0x83, 0xf4, 0x11, 0x3a, 0xc8, 0x71, 0x46, 0x72, 0xcd, 0xf3, 0xd0,
	0xbd, 0x8c, 0x93, 0xa7, 0x56, 0x3f, 0x4e, 0xfe, 0x6b, 0xa9, 0x5f, 0x43, 0x32, 0xd0, 0x6e, 0x16,
	0xea, 0x3e, 0x64, 0x0e, 0xa9, 0xcb, 0x4d, 0xdb, 0x65, 0xb3, 0xd0, 0xf7, 0x20, 0x6d, 0x60, 0x9f,
	0x0e, 0x71, 0x16, 0xf2, 0x2e, 0x2c, 0xd4, 0xac, 0xeb, 0x81, 0xed, 0x23, 0x89, 0xbd, 0x6d, 0xfc,
	0x9f, 0xa6, 0xbc, 0x72, 0xc7, 0x3e, 0x7e, 0xa6, 0x94, 0x81, 0x2e, 0xde, 0x3c, 0x9c, 0xb9, 0x0b,
	0x0b, 0x06, 0xca, 0x7f, 0xac, 0x07, 0x73, 0xf7, 0x20, 0x2d, 0xb7, 0x2d, 0xde, 0xee, 0xd4, 0x4a,
	0xc7, 0xdb, 0x9d, 0x5e, 0x4c, 0x52, 0x83, 0x4c, 0x34, 0xe1, 0x64, 0x35, 0x56, 0x61, 0x7a, 0x59,
	0xcb, 0xe5, 0xfb, 0x5c, 0x32, 0xc5, 0xc1, 0xf6, 0xb1, 0xf2, 0x75, 0xb3, 0x4b, 0xf5, 0xbe, 0xed,
	0x9b, 0x5d, 0x64, 0x9e, 0x69, 0xa1, 0x6e, 0xd1, 0x4a, 0xf0, 0x11, 0xe3, 0xe8, 0x57, 0x26, 0x1f,
	0x33, 0x8b, 0x3a, 0x17, 0x69, 0x71, 0x7a, 0xf1, 0x27, 0x00, 0x00, 0xff, 0xff, 0x67, 0x73, 0x7a,
	0x53, 0xe4, 0x06, 0x00, 0x00,
}