// Code generated by protoc-gen-twirp v8.1.3, DO NOT EDIT.
// source: spec/proto/tunnel.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

// =======================
// TunnelService Interface
// =======================

type TunnelService interface {
	MintDelegation(context.Context, *MintDelegationRequest) (*MintDelegationResponse, error)

	ListDelegations(context.Context, *ListDelegationsRequest) (*ListDelegationsResponse, error)

	RevokeDelegation(context.Context, *RevokeDelegationRequest) (*RevokeDelegationResponse, error)

	Ping(context.Context, *ClientPingRequest) (*ClientPingResponse, error)

	RegisterIdentity(context.Context, *RegisterIdentityRequest) (*RegisterIdentityResponse, error)

	GetNodes(context.Context, *GetNodesRequest) (*GetNodesResponse, error)

	GenerateHostname(context.Context, *GenerateHostnameRequest) (*GenerateHostnameResponse, error)

	RegisteredHostnames(context.Context, *RegisteredHostnamesRequest) (*RegisteredHostnamesResponse, error)

	PublishTunnel(context.Context, *PublishTunnelRequest) (*PublishTunnelResponse, error)

	UnpublishTunnel(context.Context, *UnpublishTunnelRequest) (*UnpublishTunnelResponse, error)

	ReleaseTunnel(context.Context, *ReleaseTunnelRequest) (*ReleaseTunnelResponse, error)

	AcmeInstruction(context.Context, *InstructionRequest) (*InstructionResponse, error)

	AcmeValidate(context.Context, *ValidateRequest) (*ValidateResponse, error)

	OpenEphemeralSession(context.Context, *OpenEphemeralSessionRequest) (*OpenSessionResponse, error)

	OpenDelegatedSession(context.Context, *OpenDelegatedSessionRequest) (*OpenSessionResponse, error)
}

// =============================
// TunnelService Protobuf Client
// =============================

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

// NewTunnelServiceProtobufClient creates a Protobuf client that implements the TunnelService interface.
// It communicates using Protobuf and can be configured with a custom HTTPClient.
func NewTunnelServiceProtobufClient(baseURL string, client HTTPClient, opts ...twirp.ClientOption) TunnelService {
	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", "TunnelService")
	urls := [15]string{
		serviceURL + "MintDelegation",
		serviceURL + "ListDelegations",
		serviceURL + "RevokeDelegation",
		serviceURL + "Ping",
		serviceURL + "RegisterIdentity",
		serviceURL + "GetNodes",
		serviceURL + "GenerateHostname",
		serviceURL + "RegisteredHostnames",
		serviceURL + "PublishTunnel",
		serviceURL + "UnpublishTunnel",
		serviceURL + "ReleaseTunnel",
		serviceURL + "AcmeInstruction",
		serviceURL + "AcmeValidate",
		serviceURL + "OpenEphemeralSession",
		serviceURL + "OpenDelegatedSession",
	}

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

func (c *tunnelServiceProtobufClient) MintDelegation(ctx context.Context, in *MintDelegationRequest) (*MintDelegationResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "MintDelegation")
	caller := c.callMintDelegation
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *MintDelegationRequest) (*MintDelegationResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*MintDelegationRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*MintDelegationRequest) when calling interceptor")
					}
					return c.callMintDelegation(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*MintDelegationResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*MintDelegationResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceProtobufClient) callMintDelegation(ctx context.Context, in *MintDelegationRequest) (*MintDelegationResponse, error) {
	out := new(MintDelegationResponse)
	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 *tunnelServiceProtobufClient) ListDelegations(ctx context.Context, in *ListDelegationsRequest) (*ListDelegationsResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "ListDelegations")
	caller := c.callListDelegations
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *ListDelegationsRequest) (*ListDelegationsResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ListDelegationsRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ListDelegationsRequest) when calling interceptor")
					}
					return c.callListDelegations(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ListDelegationsResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ListDelegationsResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceProtobufClient) callListDelegations(ctx context.Context, in *ListDelegationsRequest) (*ListDelegationsResponse, error) {
	out := new(ListDelegationsResponse)
	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 *tunnelServiceProtobufClient) RevokeDelegation(ctx context.Context, in *RevokeDelegationRequest) (*RevokeDelegationResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "RevokeDelegation")
	caller := c.callRevokeDelegation
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *RevokeDelegationRequest) (*RevokeDelegationResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*RevokeDelegationRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*RevokeDelegationRequest) when calling interceptor")
					}
					return c.callRevokeDelegation(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*RevokeDelegationResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*RevokeDelegationResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceProtobufClient) callRevokeDelegation(ctx context.Context, in *RevokeDelegationRequest) (*RevokeDelegationResponse, error) {
	out := new(RevokeDelegationResponse)
	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 *tunnelServiceProtobufClient) Ping(ctx context.Context, in *ClientPingRequest) (*ClientPingResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "Ping")
	caller := c.callPing
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *ClientPingRequest) (*ClientPingResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ClientPingRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ClientPingRequest) when calling interceptor")
					}
					return c.callPing(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ClientPingResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ClientPingResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceProtobufClient) callPing(ctx context.Context, in *ClientPingRequest) (*ClientPingResponse, error) {
	out := new(ClientPingResponse)
	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 *tunnelServiceProtobufClient) RegisterIdentity(ctx context.Context, in *RegisterIdentityRequest) (*RegisterIdentityResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "RegisterIdentity")
	caller := c.callRegisterIdentity
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *RegisterIdentityRequest) (*RegisterIdentityResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*RegisterIdentityRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*RegisterIdentityRequest) when calling interceptor")
					}
					return c.callRegisterIdentity(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*RegisterIdentityResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*RegisterIdentityResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceProtobufClient) callRegisterIdentity(ctx context.Context, in *RegisterIdentityRequest) (*RegisterIdentityResponse, error) {
	out := new(RegisterIdentityResponse)
	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 *tunnelServiceProtobufClient) GetNodes(ctx context.Context, in *GetNodesRequest) (*GetNodesResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "GetNodes")
	caller := c.callGetNodes
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *GetNodesRequest) (*GetNodesResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*GetNodesRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*GetNodesRequest) when calling interceptor")
					}
					return c.callGetNodes(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*GetNodesResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*GetNodesResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceProtobufClient) callGetNodes(ctx context.Context, in *GetNodesRequest) (*GetNodesResponse, error) {
	out := new(GetNodesResponse)
	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 *tunnelServiceProtobufClient) GenerateHostname(ctx context.Context, in *GenerateHostnameRequest) (*GenerateHostnameResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "GenerateHostname")
	caller := c.callGenerateHostname
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *GenerateHostnameRequest) (*GenerateHostnameResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*GenerateHostnameRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*GenerateHostnameRequest) when calling interceptor")
					}
					return c.callGenerateHostname(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*GenerateHostnameResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*GenerateHostnameResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceProtobufClient) callGenerateHostname(ctx context.Context, in *GenerateHostnameRequest) (*GenerateHostnameResponse, error) {
	out := new(GenerateHostnameResponse)
	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 *tunnelServiceProtobufClient) RegisteredHostnames(ctx context.Context, in *RegisteredHostnamesRequest) (*RegisteredHostnamesResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "RegisteredHostnames")
	caller := c.callRegisteredHostnames
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *RegisteredHostnamesRequest) (*RegisteredHostnamesResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*RegisteredHostnamesRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*RegisteredHostnamesRequest) when calling interceptor")
					}
					return c.callRegisteredHostnames(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*RegisteredHostnamesResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*RegisteredHostnamesResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceProtobufClient) callRegisteredHostnames(ctx context.Context, in *RegisteredHostnamesRequest) (*RegisteredHostnamesResponse, error) {
	out := new(RegisteredHostnamesResponse)
	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 *tunnelServiceProtobufClient) PublishTunnel(ctx context.Context, in *PublishTunnelRequest) (*PublishTunnelResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "PublishTunnel")
	caller := c.callPublishTunnel
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *PublishTunnelRequest) (*PublishTunnelResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*PublishTunnelRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*PublishTunnelRequest) when calling interceptor")
					}
					return c.callPublishTunnel(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*PublishTunnelResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*PublishTunnelResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceProtobufClient) callPublishTunnel(ctx context.Context, in *PublishTunnelRequest) (*PublishTunnelResponse, error) {
	out := new(PublishTunnelResponse)
	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 *tunnelServiceProtobufClient) UnpublishTunnel(ctx context.Context, in *UnpublishTunnelRequest) (*UnpublishTunnelResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "UnpublishTunnel")
	caller := c.callUnpublishTunnel
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *UnpublishTunnelRequest) (*UnpublishTunnelResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*UnpublishTunnelRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*UnpublishTunnelRequest) when calling interceptor")
					}
					return c.callUnpublishTunnel(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*UnpublishTunnelResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*UnpublishTunnelResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceProtobufClient) callUnpublishTunnel(ctx context.Context, in *UnpublishTunnelRequest) (*UnpublishTunnelResponse, error) {
	out := new(UnpublishTunnelResponse)
	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 *tunnelServiceProtobufClient) ReleaseTunnel(ctx context.Context, in *ReleaseTunnelRequest) (*ReleaseTunnelResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "ReleaseTunnel")
	caller := c.callReleaseTunnel
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *ReleaseTunnelRequest) (*ReleaseTunnelResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ReleaseTunnelRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ReleaseTunnelRequest) when calling interceptor")
					}
					return c.callReleaseTunnel(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ReleaseTunnelResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ReleaseTunnelResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceProtobufClient) callReleaseTunnel(ctx context.Context, in *ReleaseTunnelRequest) (*ReleaseTunnelResponse, error) {
	out := new(ReleaseTunnelResponse)
	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 *tunnelServiceProtobufClient) AcmeInstruction(ctx context.Context, in *InstructionRequest) (*InstructionResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "AcmeInstruction")
	caller := c.callAcmeInstruction
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *InstructionRequest) (*InstructionResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*InstructionRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*InstructionRequest) when calling interceptor")
					}
					return c.callAcmeInstruction(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*InstructionResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*InstructionResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceProtobufClient) callAcmeInstruction(ctx context.Context, in *InstructionRequest) (*InstructionResponse, error) {
	out := new(InstructionResponse)
	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
}

func (c *tunnelServiceProtobufClient) AcmeValidate(ctx context.Context, in *ValidateRequest) (*ValidateResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "AcmeValidate")
	caller := c.callAcmeValidate
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *ValidateRequest) (*ValidateResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ValidateRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ValidateRequest) when calling interceptor")
					}
					return c.callAcmeValidate(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ValidateResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ValidateResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceProtobufClient) callAcmeValidate(ctx context.Context, in *ValidateRequest) (*ValidateResponse, error) {
	out := new(ValidateResponse)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[12], 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 *tunnelServiceProtobufClient) OpenEphemeralSession(ctx context.Context, in *OpenEphemeralSessionRequest) (*OpenSessionResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "OpenEphemeralSession")
	caller := c.callOpenEphemeralSession
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *OpenEphemeralSessionRequest) (*OpenSessionResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*OpenEphemeralSessionRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*OpenEphemeralSessionRequest) when calling interceptor")
					}
					return c.callOpenEphemeralSession(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*OpenSessionResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*OpenSessionResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceProtobufClient) callOpenEphemeralSession(ctx context.Context, in *OpenEphemeralSessionRequest) (*OpenSessionResponse, error) {
	out := new(OpenSessionResponse)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[13], 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 *tunnelServiceProtobufClient) OpenDelegatedSession(ctx context.Context, in *OpenDelegatedSessionRequest) (*OpenSessionResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "OpenDelegatedSession")
	caller := c.callOpenDelegatedSession
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *OpenDelegatedSessionRequest) (*OpenSessionResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*OpenDelegatedSessionRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*OpenDelegatedSessionRequest) when calling interceptor")
					}
					return c.callOpenDelegatedSession(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*OpenSessionResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*OpenSessionResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceProtobufClient) callOpenDelegatedSession(ctx context.Context, in *OpenDelegatedSessionRequest) (*OpenSessionResponse, error) {
	out := new(OpenSessionResponse)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[14], 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
}

// =========================
// TunnelService JSON Client
// =========================

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

// NewTunnelServiceJSONClient creates a JSON client that implements the TunnelService interface.
// It communicates using JSON and can be configured with a custom HTTPClient.
func NewTunnelServiceJSONClient(baseURL string, client HTTPClient, opts ...twirp.ClientOption) TunnelService {
	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", "TunnelService")
	urls := [15]string{
		serviceURL + "MintDelegation",
		serviceURL + "ListDelegations",
		serviceURL + "RevokeDelegation",
		serviceURL + "Ping",
		serviceURL + "RegisterIdentity",
		serviceURL + "GetNodes",
		serviceURL + "GenerateHostname",
		serviceURL + "RegisteredHostnames",
		serviceURL + "PublishTunnel",
		serviceURL + "UnpublishTunnel",
		serviceURL + "ReleaseTunnel",
		serviceURL + "AcmeInstruction",
		serviceURL + "AcmeValidate",
		serviceURL + "OpenEphemeralSession",
		serviceURL + "OpenDelegatedSession",
	}

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

func (c *tunnelServiceJSONClient) MintDelegation(ctx context.Context, in *MintDelegationRequest) (*MintDelegationResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "MintDelegation")
	caller := c.callMintDelegation
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *MintDelegationRequest) (*MintDelegationResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*MintDelegationRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*MintDelegationRequest) when calling interceptor")
					}
					return c.callMintDelegation(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*MintDelegationResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*MintDelegationResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceJSONClient) callMintDelegation(ctx context.Context, in *MintDelegationRequest) (*MintDelegationResponse, error) {
	out := new(MintDelegationResponse)
	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 *tunnelServiceJSONClient) ListDelegations(ctx context.Context, in *ListDelegationsRequest) (*ListDelegationsResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "ListDelegations")
	caller := c.callListDelegations
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *ListDelegationsRequest) (*ListDelegationsResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ListDelegationsRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ListDelegationsRequest) when calling interceptor")
					}
					return c.callListDelegations(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ListDelegationsResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ListDelegationsResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceJSONClient) callListDelegations(ctx context.Context, in *ListDelegationsRequest) (*ListDelegationsResponse, error) {
	out := new(ListDelegationsResponse)
	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 *tunnelServiceJSONClient) RevokeDelegation(ctx context.Context, in *RevokeDelegationRequest) (*RevokeDelegationResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "RevokeDelegation")
	caller := c.callRevokeDelegation
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *RevokeDelegationRequest) (*RevokeDelegationResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*RevokeDelegationRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*RevokeDelegationRequest) when calling interceptor")
					}
					return c.callRevokeDelegation(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*RevokeDelegationResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*RevokeDelegationResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceJSONClient) callRevokeDelegation(ctx context.Context, in *RevokeDelegationRequest) (*RevokeDelegationResponse, error) {
	out := new(RevokeDelegationResponse)
	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 *tunnelServiceJSONClient) Ping(ctx context.Context, in *ClientPingRequest) (*ClientPingResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "Ping")
	caller := c.callPing
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *ClientPingRequest) (*ClientPingResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ClientPingRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ClientPingRequest) when calling interceptor")
					}
					return c.callPing(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ClientPingResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ClientPingResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceJSONClient) callPing(ctx context.Context, in *ClientPingRequest) (*ClientPingResponse, error) {
	out := new(ClientPingResponse)
	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 *tunnelServiceJSONClient) RegisterIdentity(ctx context.Context, in *RegisterIdentityRequest) (*RegisterIdentityResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "RegisterIdentity")
	caller := c.callRegisterIdentity
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *RegisterIdentityRequest) (*RegisterIdentityResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*RegisterIdentityRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*RegisterIdentityRequest) when calling interceptor")
					}
					return c.callRegisterIdentity(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*RegisterIdentityResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*RegisterIdentityResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceJSONClient) callRegisterIdentity(ctx context.Context, in *RegisterIdentityRequest) (*RegisterIdentityResponse, error) {
	out := new(RegisterIdentityResponse)
	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 *tunnelServiceJSONClient) GetNodes(ctx context.Context, in *GetNodesRequest) (*GetNodesResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "GetNodes")
	caller := c.callGetNodes
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *GetNodesRequest) (*GetNodesResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*GetNodesRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*GetNodesRequest) when calling interceptor")
					}
					return c.callGetNodes(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*GetNodesResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*GetNodesResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceJSONClient) callGetNodes(ctx context.Context, in *GetNodesRequest) (*GetNodesResponse, error) {
	out := new(GetNodesResponse)
	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 *tunnelServiceJSONClient) GenerateHostname(ctx context.Context, in *GenerateHostnameRequest) (*GenerateHostnameResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "GenerateHostname")
	caller := c.callGenerateHostname
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *GenerateHostnameRequest) (*GenerateHostnameResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*GenerateHostnameRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*GenerateHostnameRequest) when calling interceptor")
					}
					return c.callGenerateHostname(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*GenerateHostnameResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*GenerateHostnameResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceJSONClient) callGenerateHostname(ctx context.Context, in *GenerateHostnameRequest) (*GenerateHostnameResponse, error) {
	out := new(GenerateHostnameResponse)
	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 *tunnelServiceJSONClient) RegisteredHostnames(ctx context.Context, in *RegisteredHostnamesRequest) (*RegisteredHostnamesResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "RegisteredHostnames")
	caller := c.callRegisteredHostnames
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *RegisteredHostnamesRequest) (*RegisteredHostnamesResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*RegisteredHostnamesRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*RegisteredHostnamesRequest) when calling interceptor")
					}
					return c.callRegisteredHostnames(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*RegisteredHostnamesResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*RegisteredHostnamesResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceJSONClient) callRegisteredHostnames(ctx context.Context, in *RegisteredHostnamesRequest) (*RegisteredHostnamesResponse, error) {
	out := new(RegisteredHostnamesResponse)
	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 *tunnelServiceJSONClient) PublishTunnel(ctx context.Context, in *PublishTunnelRequest) (*PublishTunnelResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "PublishTunnel")
	caller := c.callPublishTunnel
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *PublishTunnelRequest) (*PublishTunnelResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*PublishTunnelRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*PublishTunnelRequest) when calling interceptor")
					}
					return c.callPublishTunnel(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*PublishTunnelResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*PublishTunnelResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceJSONClient) callPublishTunnel(ctx context.Context, in *PublishTunnelRequest) (*PublishTunnelResponse, error) {
	out := new(PublishTunnelResponse)
	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 *tunnelServiceJSONClient) UnpublishTunnel(ctx context.Context, in *UnpublishTunnelRequest) (*UnpublishTunnelResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "UnpublishTunnel")
	caller := c.callUnpublishTunnel
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *UnpublishTunnelRequest) (*UnpublishTunnelResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*UnpublishTunnelRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*UnpublishTunnelRequest) when calling interceptor")
					}
					return c.callUnpublishTunnel(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*UnpublishTunnelResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*UnpublishTunnelResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceJSONClient) callUnpublishTunnel(ctx context.Context, in *UnpublishTunnelRequest) (*UnpublishTunnelResponse, error) {
	out := new(UnpublishTunnelResponse)
	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 *tunnelServiceJSONClient) ReleaseTunnel(ctx context.Context, in *ReleaseTunnelRequest) (*ReleaseTunnelResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "ReleaseTunnel")
	caller := c.callReleaseTunnel
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *ReleaseTunnelRequest) (*ReleaseTunnelResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ReleaseTunnelRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ReleaseTunnelRequest) when calling interceptor")
					}
					return c.callReleaseTunnel(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ReleaseTunnelResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ReleaseTunnelResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceJSONClient) callReleaseTunnel(ctx context.Context, in *ReleaseTunnelRequest) (*ReleaseTunnelResponse, error) {
	out := new(ReleaseTunnelResponse)
	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 *tunnelServiceJSONClient) AcmeInstruction(ctx context.Context, in *InstructionRequest) (*InstructionResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "AcmeInstruction")
	caller := c.callAcmeInstruction
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *InstructionRequest) (*InstructionResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*InstructionRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*InstructionRequest) when calling interceptor")
					}
					return c.callAcmeInstruction(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*InstructionResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*InstructionResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceJSONClient) callAcmeInstruction(ctx context.Context, in *InstructionRequest) (*InstructionResponse, error) {
	out := new(InstructionResponse)
	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
}

func (c *tunnelServiceJSONClient) AcmeValidate(ctx context.Context, in *ValidateRequest) (*ValidateResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "AcmeValidate")
	caller := c.callAcmeValidate
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *ValidateRequest) (*ValidateResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ValidateRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ValidateRequest) when calling interceptor")
					}
					return c.callAcmeValidate(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ValidateResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ValidateResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceJSONClient) callAcmeValidate(ctx context.Context, in *ValidateRequest) (*ValidateResponse, error) {
	out := new(ValidateResponse)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[12], 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 *tunnelServiceJSONClient) OpenEphemeralSession(ctx context.Context, in *OpenEphemeralSessionRequest) (*OpenSessionResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "OpenEphemeralSession")
	caller := c.callOpenEphemeralSession
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *OpenEphemeralSessionRequest) (*OpenSessionResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*OpenEphemeralSessionRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*OpenEphemeralSessionRequest) when calling interceptor")
					}
					return c.callOpenEphemeralSession(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*OpenSessionResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*OpenSessionResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceJSONClient) callOpenEphemeralSession(ctx context.Context, in *OpenEphemeralSessionRequest) (*OpenSessionResponse, error) {
	out := new(OpenSessionResponse)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[13], 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 *tunnelServiceJSONClient) OpenDelegatedSession(ctx context.Context, in *OpenDelegatedSessionRequest) (*OpenSessionResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	ctx = ctxsetters.WithMethodName(ctx, "OpenDelegatedSession")
	caller := c.callOpenDelegatedSession
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *OpenDelegatedSessionRequest) (*OpenSessionResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*OpenDelegatedSessionRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*OpenDelegatedSessionRequest) when calling interceptor")
					}
					return c.callOpenDelegatedSession(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*OpenSessionResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*OpenSessionResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *tunnelServiceJSONClient) callOpenDelegatedSession(ctx context.Context, in *OpenDelegatedSessionRequest) (*OpenSessionResponse, error) {
	out := new(OpenSessionResponse)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[14], 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
}

// ============================
// TunnelService Server Handler
// ============================

type tunnelServiceServer struct {
	TunnelService
	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
}

// NewTunnelServiceServer 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 NewTunnelServiceServer(svc TunnelService, 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 &tunnelServiceServer{
		TunnelService:    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 *tunnelServiceServer) 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 *tunnelServiceServer) 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))
}

// TunnelServicePathPrefix 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 TunnelServicePathPrefix = "/twirp/protocol.TunnelService/"

func (s *tunnelServiceServer) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
	ctx := req.Context()
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
	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.TunnelService" {
		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 "MintDelegation":
		s.serveMintDelegation(ctx, resp, req)
		return
	case "ListDelegations":
		s.serveListDelegations(ctx, resp, req)
		return
	case "RevokeDelegation":
		s.serveRevokeDelegation(ctx, resp, req)
		return
	case "Ping":
		s.servePing(ctx, resp, req)
		return
	case "RegisterIdentity":
		s.serveRegisterIdentity(ctx, resp, req)
		return
	case "GetNodes":
		s.serveGetNodes(ctx, resp, req)
		return
	case "GenerateHostname":
		s.serveGenerateHostname(ctx, resp, req)
		return
	case "RegisteredHostnames":
		s.serveRegisteredHostnames(ctx, resp, req)
		return
	case "PublishTunnel":
		s.servePublishTunnel(ctx, resp, req)
		return
	case "UnpublishTunnel":
		s.serveUnpublishTunnel(ctx, resp, req)
		return
	case "ReleaseTunnel":
		s.serveReleaseTunnel(ctx, resp, req)
		return
	case "AcmeInstruction":
		s.serveAcmeInstruction(ctx, resp, req)
		return
	case "AcmeValidate":
		s.serveAcmeValidate(ctx, resp, req)
		return
	case "OpenEphemeralSession":
		s.serveOpenEphemeralSession(ctx, resp, req)
		return
	case "OpenDelegatedSession":
		s.serveOpenDelegatedSession(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 *tunnelServiceServer) serveMintDelegation(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.serveMintDelegationJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveMintDelegationProtobuf(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 *tunnelServiceServer) serveMintDelegationJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "MintDelegation")
	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(MintDelegationRequest)
	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.TunnelService.MintDelegation
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *MintDelegationRequest) (*MintDelegationResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*MintDelegationRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*MintDelegationRequest) when calling interceptor")
					}
					return s.TunnelService.MintDelegation(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*MintDelegationResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*MintDelegationResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *MintDelegationResponse
	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 *MintDelegationResponse and nil error while calling MintDelegation. 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 *tunnelServiceServer) serveMintDelegationProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "MintDelegation")
	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(MintDelegationRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

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

	// Call service method
	var respContent *MintDelegationResponse
	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 *MintDelegationResponse and nil error while calling MintDelegation. 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 *tunnelServiceServer) serveListDelegations(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.serveListDelegationsJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveListDelegationsProtobuf(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 *tunnelServiceServer) serveListDelegationsJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "ListDelegations")
	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(ListDelegationsRequest)
	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.TunnelService.ListDelegations
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *ListDelegationsRequest) (*ListDelegationsResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ListDelegationsRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ListDelegationsRequest) when calling interceptor")
					}
					return s.TunnelService.ListDelegations(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ListDelegationsResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ListDelegationsResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *ListDelegationsResponse
	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 *ListDelegationsResponse and nil error while calling ListDelegations. 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 *tunnelServiceServer) serveListDelegationsProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "ListDelegations")
	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(ListDelegationsRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

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

	// Call service method
	var respContent *ListDelegationsResponse
	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 *ListDelegationsResponse and nil error while calling ListDelegations. 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 *tunnelServiceServer) serveRevokeDelegation(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.serveRevokeDelegationJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveRevokeDelegationProtobuf(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 *tunnelServiceServer) serveRevokeDelegationJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "RevokeDelegation")
	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(RevokeDelegationRequest)
	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.TunnelService.RevokeDelegation
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *RevokeDelegationRequest) (*RevokeDelegationResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*RevokeDelegationRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*RevokeDelegationRequest) when calling interceptor")
					}
					return s.TunnelService.RevokeDelegation(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*RevokeDelegationResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*RevokeDelegationResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *RevokeDelegationResponse
	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 *RevokeDelegationResponse and nil error while calling RevokeDelegation. 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 *tunnelServiceServer) serveRevokeDelegationProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "RevokeDelegation")
	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(RevokeDelegationRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

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

	// Call service method
	var respContent *RevokeDelegationResponse
	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 *RevokeDelegationResponse and nil error while calling RevokeDelegation. 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 *tunnelServiceServer) servePing(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.servePingJSON(ctx, resp, req)
	case "application/protobuf":
		s.servePingProtobuf(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 *tunnelServiceServer) servePingJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "Ping")
	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(ClientPingRequest)
	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.TunnelService.Ping
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *ClientPingRequest) (*ClientPingResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ClientPingRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ClientPingRequest) when calling interceptor")
					}
					return s.TunnelService.Ping(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ClientPingResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ClientPingResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *ClientPingResponse
	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 *ClientPingResponse and nil error while calling Ping. 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 *tunnelServiceServer) servePingProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "Ping")
	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(ClientPingRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

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

	// Call service method
	var respContent *ClientPingResponse
	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 *ClientPingResponse and nil error while calling Ping. 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 *tunnelServiceServer) serveRegisterIdentity(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.serveRegisterIdentityJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveRegisterIdentityProtobuf(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 *tunnelServiceServer) serveRegisterIdentityJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "RegisterIdentity")
	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(RegisterIdentityRequest)
	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.TunnelService.RegisterIdentity
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *RegisterIdentityRequest) (*RegisterIdentityResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*RegisterIdentityRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*RegisterIdentityRequest) when calling interceptor")
					}
					return s.TunnelService.RegisterIdentity(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*RegisterIdentityResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*RegisterIdentityResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *RegisterIdentityResponse
	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 *RegisterIdentityResponse and nil error while calling RegisterIdentity. 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 *tunnelServiceServer) serveRegisterIdentityProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "RegisterIdentity")
	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(RegisterIdentityRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

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

	// Call service method
	var respContent *RegisterIdentityResponse
	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 *RegisterIdentityResponse and nil error while calling RegisterIdentity. 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 *tunnelServiceServer) serveGetNodes(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.serveGetNodesJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveGetNodesProtobuf(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 *tunnelServiceServer) serveGetNodesJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "GetNodes")
	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(GetNodesRequest)
	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.TunnelService.GetNodes
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *GetNodesRequest) (*GetNodesResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*GetNodesRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*GetNodesRequest) when calling interceptor")
					}
					return s.TunnelService.GetNodes(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*GetNodesResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*GetNodesResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *GetNodesResponse
	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 *GetNodesResponse and nil error while calling GetNodes. 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 *tunnelServiceServer) serveGetNodesProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "GetNodes")
	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(GetNodesRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

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

	// Call service method
	var respContent *GetNodesResponse
	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 *GetNodesResponse and nil error while calling GetNodes. 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 *tunnelServiceServer) serveGenerateHostname(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.serveGenerateHostnameJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveGenerateHostnameProtobuf(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 *tunnelServiceServer) serveGenerateHostnameJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "GenerateHostname")
	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(GenerateHostnameRequest)
	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.TunnelService.GenerateHostname
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *GenerateHostnameRequest) (*GenerateHostnameResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*GenerateHostnameRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*GenerateHostnameRequest) when calling interceptor")
					}
					return s.TunnelService.GenerateHostname(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*GenerateHostnameResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*GenerateHostnameResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *GenerateHostnameResponse
	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 *GenerateHostnameResponse and nil error while calling GenerateHostname. 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 *tunnelServiceServer) serveGenerateHostnameProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "GenerateHostname")
	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(GenerateHostnameRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

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

	// Call service method
	var respContent *GenerateHostnameResponse
	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 *GenerateHostnameResponse and nil error while calling GenerateHostname. 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 *tunnelServiceServer) serveRegisteredHostnames(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.serveRegisteredHostnamesJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveRegisteredHostnamesProtobuf(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 *tunnelServiceServer) serveRegisteredHostnamesJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "RegisteredHostnames")
	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(RegisteredHostnamesRequest)
	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.TunnelService.RegisteredHostnames
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *RegisteredHostnamesRequest) (*RegisteredHostnamesResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*RegisteredHostnamesRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*RegisteredHostnamesRequest) when calling interceptor")
					}
					return s.TunnelService.RegisteredHostnames(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*RegisteredHostnamesResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*RegisteredHostnamesResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *RegisteredHostnamesResponse
	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 *RegisteredHostnamesResponse and nil error while calling RegisteredHostnames. 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 *tunnelServiceServer) serveRegisteredHostnamesProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "RegisteredHostnames")
	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(RegisteredHostnamesRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

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

	// Call service method
	var respContent *RegisteredHostnamesResponse
	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 *RegisteredHostnamesResponse and nil error while calling RegisteredHostnames. 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 *tunnelServiceServer) servePublishTunnel(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.servePublishTunnelJSON(ctx, resp, req)
	case "application/protobuf":
		s.servePublishTunnelProtobuf(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 *tunnelServiceServer) servePublishTunnelJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "PublishTunnel")
	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(PublishTunnelRequest)
	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.TunnelService.PublishTunnel
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *PublishTunnelRequest) (*PublishTunnelResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*PublishTunnelRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*PublishTunnelRequest) when calling interceptor")
					}
					return s.TunnelService.PublishTunnel(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*PublishTunnelResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*PublishTunnelResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *PublishTunnelResponse
	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 *PublishTunnelResponse and nil error while calling PublishTunnel. 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 *tunnelServiceServer) servePublishTunnelProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "PublishTunnel")
	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(PublishTunnelRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

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

	// Call service method
	var respContent *PublishTunnelResponse
	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 *PublishTunnelResponse and nil error while calling PublishTunnel. 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 *tunnelServiceServer) serveUnpublishTunnel(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.serveUnpublishTunnelJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveUnpublishTunnelProtobuf(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 *tunnelServiceServer) serveUnpublishTunnelJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "UnpublishTunnel")
	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(UnpublishTunnelRequest)
	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.TunnelService.UnpublishTunnel
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *UnpublishTunnelRequest) (*UnpublishTunnelResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*UnpublishTunnelRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*UnpublishTunnelRequest) when calling interceptor")
					}
					return s.TunnelService.UnpublishTunnel(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*UnpublishTunnelResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*UnpublishTunnelResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *UnpublishTunnelResponse
	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 *UnpublishTunnelResponse and nil error while calling UnpublishTunnel. 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 *tunnelServiceServer) serveUnpublishTunnelProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "UnpublishTunnel")
	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(UnpublishTunnelRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

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

	// Call service method
	var respContent *UnpublishTunnelResponse
	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 *UnpublishTunnelResponse and nil error while calling UnpublishTunnel. 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 *tunnelServiceServer) serveReleaseTunnel(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.serveReleaseTunnelJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveReleaseTunnelProtobuf(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 *tunnelServiceServer) serveReleaseTunnelJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "ReleaseTunnel")
	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(ReleaseTunnelRequest)
	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.TunnelService.ReleaseTunnel
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *ReleaseTunnelRequest) (*ReleaseTunnelResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ReleaseTunnelRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ReleaseTunnelRequest) when calling interceptor")
					}
					return s.TunnelService.ReleaseTunnel(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ReleaseTunnelResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ReleaseTunnelResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *ReleaseTunnelResponse
	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 *ReleaseTunnelResponse and nil error while calling ReleaseTunnel. 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 *tunnelServiceServer) serveReleaseTunnelProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "ReleaseTunnel")
	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(ReleaseTunnelRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

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

	// Call service method
	var respContent *ReleaseTunnelResponse
	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 *ReleaseTunnelResponse and nil error while calling ReleaseTunnel. 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 *tunnelServiceServer) serveAcmeInstruction(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.serveAcmeInstructionJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveAcmeInstructionProtobuf(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 *tunnelServiceServer) serveAcmeInstructionJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "AcmeInstruction")
	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(InstructionRequest)
	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.TunnelService.AcmeInstruction
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *InstructionRequest) (*InstructionResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*InstructionRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*InstructionRequest) when calling interceptor")
					}
					return s.TunnelService.AcmeInstruction(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*InstructionResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*InstructionResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *InstructionResponse
	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 *InstructionResponse and nil error while calling AcmeInstruction. 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 *tunnelServiceServer) serveAcmeInstructionProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "AcmeInstruction")
	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(InstructionRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

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

	// Call service method
	var respContent *InstructionResponse
	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 *InstructionResponse and nil error while calling AcmeInstruction. 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 *tunnelServiceServer) serveAcmeValidate(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.serveAcmeValidateJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveAcmeValidateProtobuf(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 *tunnelServiceServer) serveAcmeValidateJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "AcmeValidate")
	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(ValidateRequest)
	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.TunnelService.AcmeValidate
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *ValidateRequest) (*ValidateResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ValidateRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ValidateRequest) when calling interceptor")
					}
					return s.TunnelService.AcmeValidate(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ValidateResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ValidateResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *ValidateResponse
	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 *ValidateResponse and nil error while calling AcmeValidate. 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 *tunnelServiceServer) serveAcmeValidateProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "AcmeValidate")
	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(ValidateRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

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

	// Call service method
	var respContent *ValidateResponse
	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 *ValidateResponse and nil error while calling AcmeValidate. 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 *tunnelServiceServer) serveOpenEphemeralSession(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.serveOpenEphemeralSessionJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveOpenEphemeralSessionProtobuf(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 *tunnelServiceServer) serveOpenEphemeralSessionJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "OpenEphemeralSession")
	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(OpenEphemeralSessionRequest)
	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.TunnelService.OpenEphemeralSession
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *OpenEphemeralSessionRequest) (*OpenSessionResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*OpenEphemeralSessionRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*OpenEphemeralSessionRequest) when calling interceptor")
					}
					return s.TunnelService.OpenEphemeralSession(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*OpenSessionResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*OpenSessionResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *OpenSessionResponse
	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 *OpenSessionResponse and nil error while calling OpenEphemeralSession. 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 *tunnelServiceServer) serveOpenEphemeralSessionProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "OpenEphemeralSession")
	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(OpenEphemeralSessionRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

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

	// Call service method
	var respContent *OpenSessionResponse
	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 *OpenSessionResponse and nil error while calling OpenEphemeralSession. 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 *tunnelServiceServer) serveOpenDelegatedSession(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.serveOpenDelegatedSessionJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveOpenDelegatedSessionProtobuf(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 *tunnelServiceServer) serveOpenDelegatedSessionJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "OpenDelegatedSession")
	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(OpenDelegatedSessionRequest)
	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.TunnelService.OpenDelegatedSession
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *OpenDelegatedSessionRequest) (*OpenSessionResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*OpenDelegatedSessionRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*OpenDelegatedSessionRequest) when calling interceptor")
					}
					return s.TunnelService.OpenDelegatedSession(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*OpenSessionResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*OpenSessionResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *OpenSessionResponse
	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 *OpenSessionResponse and nil error while calling OpenDelegatedSession. 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 *tunnelServiceServer) serveOpenDelegatedSessionProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "OpenDelegatedSession")
	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(OpenDelegatedSessionRequest)
	if err = reqContent.UnmarshalVT(buf); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

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

	// Call service method
	var respContent *OpenSessionResponse
	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 *OpenSessionResponse and nil error while calling OpenDelegatedSession. 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 *tunnelServiceServer) ServiceDescriptor() ([]byte, int) {
	return twirpFileDescriptor5, 0
}

func (s *tunnelServiceServer) 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 *tunnelServiceServer) PathPrefix() string {
	return baseServicePath(s.pathPrefix, "protocol", "TunnelService")
}

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