livekit-protocol 0.7.5

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

package livekit

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 proto "google.golang.org/protobuf/proto"
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

// =========================
// AgentSimulation Interface
// =========================

type AgentSimulation interface {
	CreateSimulationRun(context.Context, *SimulationRun_Create_Request) (*SimulationRun_Create_Response, error)

	ConfirmSimulationSourceUpload(context.Context, *SimulationRun_ConfirmSourceUpload_Request) (*SimulationRun_ConfirmSourceUpload_Response, error)

	GetSimulationRun(context.Context, *SimulationRun_Get_Request) (*SimulationRun_Get_Response, error)

	ListSimulationRuns(context.Context, *SimulationRun_List_Request) (*SimulationRun_List_Response, error)

	CancelSimulationRun(context.Context, *SimulationRun_Cancel_Request) (*SimulationRun_Cancel_Response, error)

	CreateScenario(context.Context, *Scenario_Create_Request) (*Scenario_Create_Response, error)

	CreateScenarioFromSession(context.Context, *Scenario_CreateFromSession_Request) (*Scenario_CreateFromSession_Response, error)

	DeleteScenario(context.Context, *Scenario_Delete_Request) (*Scenario_Delete_Response, error)

	UpdateScenario(context.Context, *Scenario_Update_Request) (*Scenario_Update_Response, error)

	CreateScenarioGroup(context.Context, *ScenarioGroup_Create_Request) (*ScenarioGroup_Create_Response, error)

	DeleteScenarioGroup(context.Context, *ScenarioGroup_Delete_Request) (*ScenarioGroup_Delete_Response, error)

	ListScenarioGroups(context.Context, *ScenarioGroup_List_Request) (*ScenarioGroup_List_Response, error)

	ListScenarios(context.Context, *Scenario_List_Request) (*Scenario_List_Response, error)
}

// ===============================
// AgentSimulation Protobuf Client
// ===============================

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

// NewAgentSimulationProtobufClient creates a Protobuf client that implements the AgentSimulation interface.
// It communicates using Protobuf and can be configured with a custom HTTPClient.
func NewAgentSimulationProtobufClient(baseURL string, client HTTPClient, opts ...twirp.ClientOption) AgentSimulation {
	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, "livekit", "AgentSimulation")
	urls := [13]string{
		serviceURL + "CreateSimulationRun",
		serviceURL + "ConfirmSimulationSourceUpload",
		serviceURL + "GetSimulationRun",
		serviceURL + "ListSimulationRuns",
		serviceURL + "CancelSimulationRun",
		serviceURL + "CreateScenario",
		serviceURL + "CreateScenarioFromSession",
		serviceURL + "DeleteScenario",
		serviceURL + "UpdateScenario",
		serviceURL + "CreateScenarioGroup",
		serviceURL + "DeleteScenarioGroup",
		serviceURL + "ListScenarioGroups",
		serviceURL + "ListScenarios",
	}

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

func (c *agentSimulationProtobufClient) CreateSimulationRun(ctx context.Context, in *SimulationRun_Create_Request) (*SimulationRun_Create_Response, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	ctx = ctxsetters.WithMethodName(ctx, "CreateSimulationRun")
	caller := c.callCreateSimulationRun
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *SimulationRun_Create_Request) (*SimulationRun_Create_Response, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimulationRun_Create_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimulationRun_Create_Request) when calling interceptor")
					}
					return c.callCreateSimulationRun(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimulationRun_Create_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimulationRun_Create_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *agentSimulationProtobufClient) callCreateSimulationRun(ctx context.Context, in *SimulationRun_Create_Request) (*SimulationRun_Create_Response, error) {
	out := new(SimulationRun_Create_Response)
	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 *agentSimulationProtobufClient) ConfirmSimulationSourceUpload(ctx context.Context, in *SimulationRun_ConfirmSourceUpload_Request) (*SimulationRun_ConfirmSourceUpload_Response, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	ctx = ctxsetters.WithMethodName(ctx, "ConfirmSimulationSourceUpload")
	caller := c.callConfirmSimulationSourceUpload
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *SimulationRun_ConfirmSourceUpload_Request) (*SimulationRun_ConfirmSourceUpload_Response, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimulationRun_ConfirmSourceUpload_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimulationRun_ConfirmSourceUpload_Request) when calling interceptor")
					}
					return c.callConfirmSimulationSourceUpload(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimulationRun_ConfirmSourceUpload_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimulationRun_ConfirmSourceUpload_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *agentSimulationProtobufClient) callConfirmSimulationSourceUpload(ctx context.Context, in *SimulationRun_ConfirmSourceUpload_Request) (*SimulationRun_ConfirmSourceUpload_Response, error) {
	out := new(SimulationRun_ConfirmSourceUpload_Response)
	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 *agentSimulationProtobufClient) GetSimulationRun(ctx context.Context, in *SimulationRun_Get_Request) (*SimulationRun_Get_Response, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	ctx = ctxsetters.WithMethodName(ctx, "GetSimulationRun")
	caller := c.callGetSimulationRun
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *SimulationRun_Get_Request) (*SimulationRun_Get_Response, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimulationRun_Get_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimulationRun_Get_Request) when calling interceptor")
					}
					return c.callGetSimulationRun(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimulationRun_Get_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimulationRun_Get_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *agentSimulationProtobufClient) callGetSimulationRun(ctx context.Context, in *SimulationRun_Get_Request) (*SimulationRun_Get_Response, error) {
	out := new(SimulationRun_Get_Response)
	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 *agentSimulationProtobufClient) ListSimulationRuns(ctx context.Context, in *SimulationRun_List_Request) (*SimulationRun_List_Response, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	ctx = ctxsetters.WithMethodName(ctx, "ListSimulationRuns")
	caller := c.callListSimulationRuns
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *SimulationRun_List_Request) (*SimulationRun_List_Response, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimulationRun_List_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimulationRun_List_Request) when calling interceptor")
					}
					return c.callListSimulationRuns(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimulationRun_List_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimulationRun_List_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *agentSimulationProtobufClient) callListSimulationRuns(ctx context.Context, in *SimulationRun_List_Request) (*SimulationRun_List_Response, error) {
	out := new(SimulationRun_List_Response)
	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 *agentSimulationProtobufClient) CancelSimulationRun(ctx context.Context, in *SimulationRun_Cancel_Request) (*SimulationRun_Cancel_Response, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	ctx = ctxsetters.WithMethodName(ctx, "CancelSimulationRun")
	caller := c.callCancelSimulationRun
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *SimulationRun_Cancel_Request) (*SimulationRun_Cancel_Response, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimulationRun_Cancel_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimulationRun_Cancel_Request) when calling interceptor")
					}
					return c.callCancelSimulationRun(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimulationRun_Cancel_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimulationRun_Cancel_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *agentSimulationProtobufClient) callCancelSimulationRun(ctx context.Context, in *SimulationRun_Cancel_Request) (*SimulationRun_Cancel_Response, error) {
	out := new(SimulationRun_Cancel_Response)
	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 *agentSimulationProtobufClient) CreateScenario(ctx context.Context, in *Scenario_Create_Request) (*Scenario_Create_Response, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	ctx = ctxsetters.WithMethodName(ctx, "CreateScenario")
	caller := c.callCreateScenario
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *Scenario_Create_Request) (*Scenario_Create_Response, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*Scenario_Create_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*Scenario_Create_Request) when calling interceptor")
					}
					return c.callCreateScenario(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*Scenario_Create_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*Scenario_Create_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *agentSimulationProtobufClient) callCreateScenario(ctx context.Context, in *Scenario_Create_Request) (*Scenario_Create_Response, error) {
	out := new(Scenario_Create_Response)
	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 *agentSimulationProtobufClient) CreateScenarioFromSession(ctx context.Context, in *Scenario_CreateFromSession_Request) (*Scenario_CreateFromSession_Response, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	ctx = ctxsetters.WithMethodName(ctx, "CreateScenarioFromSession")
	caller := c.callCreateScenarioFromSession
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *Scenario_CreateFromSession_Request) (*Scenario_CreateFromSession_Response, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*Scenario_CreateFromSession_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*Scenario_CreateFromSession_Request) when calling interceptor")
					}
					return c.callCreateScenarioFromSession(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*Scenario_CreateFromSession_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*Scenario_CreateFromSession_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *agentSimulationProtobufClient) callCreateScenarioFromSession(ctx context.Context, in *Scenario_CreateFromSession_Request) (*Scenario_CreateFromSession_Response, error) {
	out := new(Scenario_CreateFromSession_Response)
	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 *agentSimulationProtobufClient) DeleteScenario(ctx context.Context, in *Scenario_Delete_Request) (*Scenario_Delete_Response, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	ctx = ctxsetters.WithMethodName(ctx, "DeleteScenario")
	caller := c.callDeleteScenario
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *Scenario_Delete_Request) (*Scenario_Delete_Response, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*Scenario_Delete_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*Scenario_Delete_Request) when calling interceptor")
					}
					return c.callDeleteScenario(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*Scenario_Delete_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*Scenario_Delete_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *agentSimulationProtobufClient) callDeleteScenario(ctx context.Context, in *Scenario_Delete_Request) (*Scenario_Delete_Response, error) {
	out := new(Scenario_Delete_Response)
	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 *agentSimulationProtobufClient) UpdateScenario(ctx context.Context, in *Scenario_Update_Request) (*Scenario_Update_Response, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	ctx = ctxsetters.WithMethodName(ctx, "UpdateScenario")
	caller := c.callUpdateScenario
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *Scenario_Update_Request) (*Scenario_Update_Response, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*Scenario_Update_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*Scenario_Update_Request) when calling interceptor")
					}
					return c.callUpdateScenario(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*Scenario_Update_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*Scenario_Update_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *agentSimulationProtobufClient) callUpdateScenario(ctx context.Context, in *Scenario_Update_Request) (*Scenario_Update_Response, error) {
	out := new(Scenario_Update_Response)
	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 *agentSimulationProtobufClient) CreateScenarioGroup(ctx context.Context, in *ScenarioGroup_Create_Request) (*ScenarioGroup_Create_Response, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	ctx = ctxsetters.WithMethodName(ctx, "CreateScenarioGroup")
	caller := c.callCreateScenarioGroup
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *ScenarioGroup_Create_Request) (*ScenarioGroup_Create_Response, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ScenarioGroup_Create_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ScenarioGroup_Create_Request) when calling interceptor")
					}
					return c.callCreateScenarioGroup(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ScenarioGroup_Create_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ScenarioGroup_Create_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *agentSimulationProtobufClient) callCreateScenarioGroup(ctx context.Context, in *ScenarioGroup_Create_Request) (*ScenarioGroup_Create_Response, error) {
	out := new(ScenarioGroup_Create_Response)
	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 *agentSimulationProtobufClient) DeleteScenarioGroup(ctx context.Context, in *ScenarioGroup_Delete_Request) (*ScenarioGroup_Delete_Response, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	ctx = ctxsetters.WithMethodName(ctx, "DeleteScenarioGroup")
	caller := c.callDeleteScenarioGroup
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *ScenarioGroup_Delete_Request) (*ScenarioGroup_Delete_Response, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ScenarioGroup_Delete_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ScenarioGroup_Delete_Request) when calling interceptor")
					}
					return c.callDeleteScenarioGroup(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ScenarioGroup_Delete_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ScenarioGroup_Delete_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *agentSimulationProtobufClient) callDeleteScenarioGroup(ctx context.Context, in *ScenarioGroup_Delete_Request) (*ScenarioGroup_Delete_Response, error) {
	out := new(ScenarioGroup_Delete_Response)
	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 *agentSimulationProtobufClient) ListScenarioGroups(ctx context.Context, in *ScenarioGroup_List_Request) (*ScenarioGroup_List_Response, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	ctx = ctxsetters.WithMethodName(ctx, "ListScenarioGroups")
	caller := c.callListScenarioGroups
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *ScenarioGroup_List_Request) (*ScenarioGroup_List_Response, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ScenarioGroup_List_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ScenarioGroup_List_Request) when calling interceptor")
					}
					return c.callListScenarioGroups(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ScenarioGroup_List_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ScenarioGroup_List_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *agentSimulationProtobufClient) callListScenarioGroups(ctx context.Context, in *ScenarioGroup_List_Request) (*ScenarioGroup_List_Response, error) {
	out := new(ScenarioGroup_List_Response)
	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 *agentSimulationProtobufClient) ListScenarios(ctx context.Context, in *Scenario_List_Request) (*Scenario_List_Response, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	ctx = ctxsetters.WithMethodName(ctx, "ListScenarios")
	caller := c.callListScenarios
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *Scenario_List_Request) (*Scenario_List_Response, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*Scenario_List_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*Scenario_List_Request) when calling interceptor")
					}
					return c.callListScenarios(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*Scenario_List_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*Scenario_List_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *agentSimulationProtobufClient) callListScenarios(ctx context.Context, in *Scenario_List_Request) (*Scenario_List_Response, error) {
	out := new(Scenario_List_Response)
	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
}

// ===========================
// AgentSimulation JSON Client
// ===========================

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

// NewAgentSimulationJSONClient creates a JSON client that implements the AgentSimulation interface.
// It communicates using JSON and can be configured with a custom HTTPClient.
func NewAgentSimulationJSONClient(baseURL string, client HTTPClient, opts ...twirp.ClientOption) AgentSimulation {
	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, "livekit", "AgentSimulation")
	urls := [13]string{
		serviceURL + "CreateSimulationRun",
		serviceURL + "ConfirmSimulationSourceUpload",
		serviceURL + "GetSimulationRun",
		serviceURL + "ListSimulationRuns",
		serviceURL + "CancelSimulationRun",
		serviceURL + "CreateScenario",
		serviceURL + "CreateScenarioFromSession",
		serviceURL + "DeleteScenario",
		serviceURL + "UpdateScenario",
		serviceURL + "CreateScenarioGroup",
		serviceURL + "DeleteScenarioGroup",
		serviceURL + "ListScenarioGroups",
		serviceURL + "ListScenarios",
	}

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

func (c *agentSimulationJSONClient) CreateSimulationRun(ctx context.Context, in *SimulationRun_Create_Request) (*SimulationRun_Create_Response, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	ctx = ctxsetters.WithMethodName(ctx, "CreateSimulationRun")
	caller := c.callCreateSimulationRun
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *SimulationRun_Create_Request) (*SimulationRun_Create_Response, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimulationRun_Create_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimulationRun_Create_Request) when calling interceptor")
					}
					return c.callCreateSimulationRun(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimulationRun_Create_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimulationRun_Create_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *agentSimulationJSONClient) callCreateSimulationRun(ctx context.Context, in *SimulationRun_Create_Request) (*SimulationRun_Create_Response, error) {
	out := new(SimulationRun_Create_Response)
	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 *agentSimulationJSONClient) ConfirmSimulationSourceUpload(ctx context.Context, in *SimulationRun_ConfirmSourceUpload_Request) (*SimulationRun_ConfirmSourceUpload_Response, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	ctx = ctxsetters.WithMethodName(ctx, "ConfirmSimulationSourceUpload")
	caller := c.callConfirmSimulationSourceUpload
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *SimulationRun_ConfirmSourceUpload_Request) (*SimulationRun_ConfirmSourceUpload_Response, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimulationRun_ConfirmSourceUpload_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimulationRun_ConfirmSourceUpload_Request) when calling interceptor")
					}
					return c.callConfirmSimulationSourceUpload(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimulationRun_ConfirmSourceUpload_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimulationRun_ConfirmSourceUpload_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *agentSimulationJSONClient) callConfirmSimulationSourceUpload(ctx context.Context, in *SimulationRun_ConfirmSourceUpload_Request) (*SimulationRun_ConfirmSourceUpload_Response, error) {
	out := new(SimulationRun_ConfirmSourceUpload_Response)
	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 *agentSimulationJSONClient) GetSimulationRun(ctx context.Context, in *SimulationRun_Get_Request) (*SimulationRun_Get_Response, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	ctx = ctxsetters.WithMethodName(ctx, "GetSimulationRun")
	caller := c.callGetSimulationRun
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *SimulationRun_Get_Request) (*SimulationRun_Get_Response, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimulationRun_Get_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimulationRun_Get_Request) when calling interceptor")
					}
					return c.callGetSimulationRun(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimulationRun_Get_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimulationRun_Get_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *agentSimulationJSONClient) callGetSimulationRun(ctx context.Context, in *SimulationRun_Get_Request) (*SimulationRun_Get_Response, error) {
	out := new(SimulationRun_Get_Response)
	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 *agentSimulationJSONClient) ListSimulationRuns(ctx context.Context, in *SimulationRun_List_Request) (*SimulationRun_List_Response, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	ctx = ctxsetters.WithMethodName(ctx, "ListSimulationRuns")
	caller := c.callListSimulationRuns
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *SimulationRun_List_Request) (*SimulationRun_List_Response, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimulationRun_List_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimulationRun_List_Request) when calling interceptor")
					}
					return c.callListSimulationRuns(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimulationRun_List_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimulationRun_List_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *agentSimulationJSONClient) callListSimulationRuns(ctx context.Context, in *SimulationRun_List_Request) (*SimulationRun_List_Response, error) {
	out := new(SimulationRun_List_Response)
	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 *agentSimulationJSONClient) CancelSimulationRun(ctx context.Context, in *SimulationRun_Cancel_Request) (*SimulationRun_Cancel_Response, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	ctx = ctxsetters.WithMethodName(ctx, "CancelSimulationRun")
	caller := c.callCancelSimulationRun
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *SimulationRun_Cancel_Request) (*SimulationRun_Cancel_Response, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimulationRun_Cancel_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimulationRun_Cancel_Request) when calling interceptor")
					}
					return c.callCancelSimulationRun(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimulationRun_Cancel_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimulationRun_Cancel_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *agentSimulationJSONClient) callCancelSimulationRun(ctx context.Context, in *SimulationRun_Cancel_Request) (*SimulationRun_Cancel_Response, error) {
	out := new(SimulationRun_Cancel_Response)
	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 *agentSimulationJSONClient) CreateScenario(ctx context.Context, in *Scenario_Create_Request) (*Scenario_Create_Response, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	ctx = ctxsetters.WithMethodName(ctx, "CreateScenario")
	caller := c.callCreateScenario
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *Scenario_Create_Request) (*Scenario_Create_Response, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*Scenario_Create_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*Scenario_Create_Request) when calling interceptor")
					}
					return c.callCreateScenario(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*Scenario_Create_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*Scenario_Create_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *agentSimulationJSONClient) callCreateScenario(ctx context.Context, in *Scenario_Create_Request) (*Scenario_Create_Response, error) {
	out := new(Scenario_Create_Response)
	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 *agentSimulationJSONClient) CreateScenarioFromSession(ctx context.Context, in *Scenario_CreateFromSession_Request) (*Scenario_CreateFromSession_Response, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	ctx = ctxsetters.WithMethodName(ctx, "CreateScenarioFromSession")
	caller := c.callCreateScenarioFromSession
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *Scenario_CreateFromSession_Request) (*Scenario_CreateFromSession_Response, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*Scenario_CreateFromSession_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*Scenario_CreateFromSession_Request) when calling interceptor")
					}
					return c.callCreateScenarioFromSession(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*Scenario_CreateFromSession_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*Scenario_CreateFromSession_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *agentSimulationJSONClient) callCreateScenarioFromSession(ctx context.Context, in *Scenario_CreateFromSession_Request) (*Scenario_CreateFromSession_Response, error) {
	out := new(Scenario_CreateFromSession_Response)
	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 *agentSimulationJSONClient) DeleteScenario(ctx context.Context, in *Scenario_Delete_Request) (*Scenario_Delete_Response, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	ctx = ctxsetters.WithMethodName(ctx, "DeleteScenario")
	caller := c.callDeleteScenario
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *Scenario_Delete_Request) (*Scenario_Delete_Response, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*Scenario_Delete_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*Scenario_Delete_Request) when calling interceptor")
					}
					return c.callDeleteScenario(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*Scenario_Delete_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*Scenario_Delete_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *agentSimulationJSONClient) callDeleteScenario(ctx context.Context, in *Scenario_Delete_Request) (*Scenario_Delete_Response, error) {
	out := new(Scenario_Delete_Response)
	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 *agentSimulationJSONClient) UpdateScenario(ctx context.Context, in *Scenario_Update_Request) (*Scenario_Update_Response, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	ctx = ctxsetters.WithMethodName(ctx, "UpdateScenario")
	caller := c.callUpdateScenario
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *Scenario_Update_Request) (*Scenario_Update_Response, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*Scenario_Update_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*Scenario_Update_Request) when calling interceptor")
					}
					return c.callUpdateScenario(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*Scenario_Update_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*Scenario_Update_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *agentSimulationJSONClient) callUpdateScenario(ctx context.Context, in *Scenario_Update_Request) (*Scenario_Update_Response, error) {
	out := new(Scenario_Update_Response)
	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 *agentSimulationJSONClient) CreateScenarioGroup(ctx context.Context, in *ScenarioGroup_Create_Request) (*ScenarioGroup_Create_Response, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	ctx = ctxsetters.WithMethodName(ctx, "CreateScenarioGroup")
	caller := c.callCreateScenarioGroup
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *ScenarioGroup_Create_Request) (*ScenarioGroup_Create_Response, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ScenarioGroup_Create_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ScenarioGroup_Create_Request) when calling interceptor")
					}
					return c.callCreateScenarioGroup(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ScenarioGroup_Create_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ScenarioGroup_Create_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *agentSimulationJSONClient) callCreateScenarioGroup(ctx context.Context, in *ScenarioGroup_Create_Request) (*ScenarioGroup_Create_Response, error) {
	out := new(ScenarioGroup_Create_Response)
	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 *agentSimulationJSONClient) DeleteScenarioGroup(ctx context.Context, in *ScenarioGroup_Delete_Request) (*ScenarioGroup_Delete_Response, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	ctx = ctxsetters.WithMethodName(ctx, "DeleteScenarioGroup")
	caller := c.callDeleteScenarioGroup
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *ScenarioGroup_Delete_Request) (*ScenarioGroup_Delete_Response, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ScenarioGroup_Delete_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ScenarioGroup_Delete_Request) when calling interceptor")
					}
					return c.callDeleteScenarioGroup(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ScenarioGroup_Delete_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ScenarioGroup_Delete_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *agentSimulationJSONClient) callDeleteScenarioGroup(ctx context.Context, in *ScenarioGroup_Delete_Request) (*ScenarioGroup_Delete_Response, error) {
	out := new(ScenarioGroup_Delete_Response)
	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 *agentSimulationJSONClient) ListScenarioGroups(ctx context.Context, in *ScenarioGroup_List_Request) (*ScenarioGroup_List_Response, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	ctx = ctxsetters.WithMethodName(ctx, "ListScenarioGroups")
	caller := c.callListScenarioGroups
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *ScenarioGroup_List_Request) (*ScenarioGroup_List_Response, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ScenarioGroup_List_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ScenarioGroup_List_Request) when calling interceptor")
					}
					return c.callListScenarioGroups(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ScenarioGroup_List_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ScenarioGroup_List_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *agentSimulationJSONClient) callListScenarioGroups(ctx context.Context, in *ScenarioGroup_List_Request) (*ScenarioGroup_List_Response, error) {
	out := new(ScenarioGroup_List_Response)
	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 *agentSimulationJSONClient) ListScenarios(ctx context.Context, in *Scenario_List_Request) (*Scenario_List_Response, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	ctx = ctxsetters.WithMethodName(ctx, "ListScenarios")
	caller := c.callListScenarios
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *Scenario_List_Request) (*Scenario_List_Response, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*Scenario_List_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*Scenario_List_Request) when calling interceptor")
					}
					return c.callListScenarios(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*Scenario_List_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*Scenario_List_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *agentSimulationJSONClient) callListScenarios(ctx context.Context, in *Scenario_List_Request) (*Scenario_List_Response, error) {
	out := new(Scenario_List_Response)
	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
}

// ==============================
// AgentSimulation Server Handler
// ==============================

type agentSimulationServer struct {
	AgentSimulation
	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
}

// NewAgentSimulationServer 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 NewAgentSimulationServer(svc AgentSimulation, 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 &agentSimulationServer{
		AgentSimulation:  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 *agentSimulationServer) 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 *agentSimulationServer) 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))
}

// AgentSimulationPathPrefix 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 AgentSimulationPathPrefix = "/twirp/livekit.AgentSimulation/"

func (s *agentSimulationServer) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
	ctx := req.Context()
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "AgentSimulation")
	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 != "livekit.AgentSimulation" {
		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 "CreateSimulationRun":
		s.serveCreateSimulationRun(ctx, resp, req)
		return
	case "ConfirmSimulationSourceUpload":
		s.serveConfirmSimulationSourceUpload(ctx, resp, req)
		return
	case "GetSimulationRun":
		s.serveGetSimulationRun(ctx, resp, req)
		return
	case "ListSimulationRuns":
		s.serveListSimulationRuns(ctx, resp, req)
		return
	case "CancelSimulationRun":
		s.serveCancelSimulationRun(ctx, resp, req)
		return
	case "CreateScenario":
		s.serveCreateScenario(ctx, resp, req)
		return
	case "CreateScenarioFromSession":
		s.serveCreateScenarioFromSession(ctx, resp, req)
		return
	case "DeleteScenario":
		s.serveDeleteScenario(ctx, resp, req)
		return
	case "UpdateScenario":
		s.serveUpdateScenario(ctx, resp, req)
		return
	case "CreateScenarioGroup":
		s.serveCreateScenarioGroup(ctx, resp, req)
		return
	case "DeleteScenarioGroup":
		s.serveDeleteScenarioGroup(ctx, resp, req)
		return
	case "ListScenarioGroups":
		s.serveListScenarioGroups(ctx, resp, req)
		return
	case "ListScenarios":
		s.serveListScenarios(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 *agentSimulationServer) serveCreateSimulationRun(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.serveCreateSimulationRunJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveCreateSimulationRunProtobuf(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 *agentSimulationServer) serveCreateSimulationRunJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "CreateSimulationRun")
	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(SimulationRun_Create_Request)
	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.AgentSimulation.CreateSimulationRun
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *SimulationRun_Create_Request) (*SimulationRun_Create_Response, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimulationRun_Create_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimulationRun_Create_Request) when calling interceptor")
					}
					return s.AgentSimulation.CreateSimulationRun(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimulationRun_Create_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimulationRun_Create_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

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

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

	// Call service method
	var respContent *SimulationRun_Create_Response
	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 *SimulationRun_Create_Response and nil error while calling CreateSimulationRun. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	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 *agentSimulationServer) serveConfirmSimulationSourceUpload(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.serveConfirmSimulationSourceUploadJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveConfirmSimulationSourceUploadProtobuf(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 *agentSimulationServer) serveConfirmSimulationSourceUploadJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "ConfirmSimulationSourceUpload")
	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(SimulationRun_ConfirmSourceUpload_Request)
	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.AgentSimulation.ConfirmSimulationSourceUpload
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *SimulationRun_ConfirmSourceUpload_Request) (*SimulationRun_ConfirmSourceUpload_Response, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimulationRun_ConfirmSourceUpload_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimulationRun_ConfirmSourceUpload_Request) when calling interceptor")
					}
					return s.AgentSimulation.ConfirmSimulationSourceUpload(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimulationRun_ConfirmSourceUpload_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimulationRun_ConfirmSourceUpload_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

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

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

	// Call service method
	var respContent *SimulationRun_ConfirmSourceUpload_Response
	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 *SimulationRun_ConfirmSourceUpload_Response and nil error while calling ConfirmSimulationSourceUpload. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	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 *agentSimulationServer) serveGetSimulationRun(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.serveGetSimulationRunJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveGetSimulationRunProtobuf(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 *agentSimulationServer) serveGetSimulationRunJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "GetSimulationRun")
	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(SimulationRun_Get_Request)
	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.AgentSimulation.GetSimulationRun
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *SimulationRun_Get_Request) (*SimulationRun_Get_Response, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimulationRun_Get_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimulationRun_Get_Request) when calling interceptor")
					}
					return s.AgentSimulation.GetSimulationRun(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimulationRun_Get_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimulationRun_Get_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

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

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

	// Call service method
	var respContent *SimulationRun_Get_Response
	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 *SimulationRun_Get_Response and nil error while calling GetSimulationRun. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	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 *agentSimulationServer) serveListSimulationRuns(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.serveListSimulationRunsJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveListSimulationRunsProtobuf(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 *agentSimulationServer) serveListSimulationRunsJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "ListSimulationRuns")
	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(SimulationRun_List_Request)
	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.AgentSimulation.ListSimulationRuns
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *SimulationRun_List_Request) (*SimulationRun_List_Response, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimulationRun_List_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimulationRun_List_Request) when calling interceptor")
					}
					return s.AgentSimulation.ListSimulationRuns(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimulationRun_List_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimulationRun_List_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

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

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

	// Call service method
	var respContent *SimulationRun_List_Response
	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 *SimulationRun_List_Response and nil error while calling ListSimulationRuns. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	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 *agentSimulationServer) serveCancelSimulationRun(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.serveCancelSimulationRunJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveCancelSimulationRunProtobuf(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 *agentSimulationServer) serveCancelSimulationRunJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "CancelSimulationRun")
	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(SimulationRun_Cancel_Request)
	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.AgentSimulation.CancelSimulationRun
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *SimulationRun_Cancel_Request) (*SimulationRun_Cancel_Response, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*SimulationRun_Cancel_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*SimulationRun_Cancel_Request) when calling interceptor")
					}
					return s.AgentSimulation.CancelSimulationRun(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SimulationRun_Cancel_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SimulationRun_Cancel_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

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

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

	// Call service method
	var respContent *SimulationRun_Cancel_Response
	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 *SimulationRun_Cancel_Response and nil error while calling CancelSimulationRun. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	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 *agentSimulationServer) serveCreateScenario(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.serveCreateScenarioJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveCreateScenarioProtobuf(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 *agentSimulationServer) serveCreateScenarioJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "CreateScenario")
	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(Scenario_Create_Request)
	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.AgentSimulation.CreateScenario
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *Scenario_Create_Request) (*Scenario_Create_Response, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*Scenario_Create_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*Scenario_Create_Request) when calling interceptor")
					}
					return s.AgentSimulation.CreateScenario(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*Scenario_Create_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*Scenario_Create_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

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

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

	// Call service method
	var respContent *Scenario_Create_Response
	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 *Scenario_Create_Response and nil error while calling CreateScenario. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	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 *agentSimulationServer) serveCreateScenarioFromSession(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.serveCreateScenarioFromSessionJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveCreateScenarioFromSessionProtobuf(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 *agentSimulationServer) serveCreateScenarioFromSessionJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "CreateScenarioFromSession")
	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(Scenario_CreateFromSession_Request)
	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.AgentSimulation.CreateScenarioFromSession
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *Scenario_CreateFromSession_Request) (*Scenario_CreateFromSession_Response, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*Scenario_CreateFromSession_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*Scenario_CreateFromSession_Request) when calling interceptor")
					}
					return s.AgentSimulation.CreateScenarioFromSession(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*Scenario_CreateFromSession_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*Scenario_CreateFromSession_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

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

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

	// Call service method
	var respContent *Scenario_CreateFromSession_Response
	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 *Scenario_CreateFromSession_Response and nil error while calling CreateScenarioFromSession. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	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 *agentSimulationServer) serveDeleteScenario(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.serveDeleteScenarioJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveDeleteScenarioProtobuf(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 *agentSimulationServer) serveDeleteScenarioJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "DeleteScenario")
	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(Scenario_Delete_Request)
	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.AgentSimulation.DeleteScenario
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *Scenario_Delete_Request) (*Scenario_Delete_Response, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*Scenario_Delete_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*Scenario_Delete_Request) when calling interceptor")
					}
					return s.AgentSimulation.DeleteScenario(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*Scenario_Delete_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*Scenario_Delete_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

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

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

	// Call service method
	var respContent *Scenario_Delete_Response
	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 *Scenario_Delete_Response and nil error while calling DeleteScenario. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	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 *agentSimulationServer) serveUpdateScenario(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.serveUpdateScenarioJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveUpdateScenarioProtobuf(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 *agentSimulationServer) serveUpdateScenarioJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "UpdateScenario")
	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(Scenario_Update_Request)
	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.AgentSimulation.UpdateScenario
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *Scenario_Update_Request) (*Scenario_Update_Response, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*Scenario_Update_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*Scenario_Update_Request) when calling interceptor")
					}
					return s.AgentSimulation.UpdateScenario(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*Scenario_Update_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*Scenario_Update_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

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

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

	// Call service method
	var respContent *Scenario_Update_Response
	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 *Scenario_Update_Response and nil error while calling UpdateScenario. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	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 *agentSimulationServer) serveCreateScenarioGroup(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.serveCreateScenarioGroupJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveCreateScenarioGroupProtobuf(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 *agentSimulationServer) serveCreateScenarioGroupJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "CreateScenarioGroup")
	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(ScenarioGroup_Create_Request)
	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.AgentSimulation.CreateScenarioGroup
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *ScenarioGroup_Create_Request) (*ScenarioGroup_Create_Response, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ScenarioGroup_Create_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ScenarioGroup_Create_Request) when calling interceptor")
					}
					return s.AgentSimulation.CreateScenarioGroup(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ScenarioGroup_Create_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ScenarioGroup_Create_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

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

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

	// Call service method
	var respContent *ScenarioGroup_Create_Response
	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 *ScenarioGroup_Create_Response and nil error while calling CreateScenarioGroup. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	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 *agentSimulationServer) serveDeleteScenarioGroup(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.serveDeleteScenarioGroupJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveDeleteScenarioGroupProtobuf(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 *agentSimulationServer) serveDeleteScenarioGroupJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "DeleteScenarioGroup")
	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(ScenarioGroup_Delete_Request)
	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.AgentSimulation.DeleteScenarioGroup
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *ScenarioGroup_Delete_Request) (*ScenarioGroup_Delete_Response, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ScenarioGroup_Delete_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ScenarioGroup_Delete_Request) when calling interceptor")
					}
					return s.AgentSimulation.DeleteScenarioGroup(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ScenarioGroup_Delete_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ScenarioGroup_Delete_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

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

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

	// Call service method
	var respContent *ScenarioGroup_Delete_Response
	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 *ScenarioGroup_Delete_Response and nil error while calling DeleteScenarioGroup. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	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 *agentSimulationServer) serveListScenarioGroups(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.serveListScenarioGroupsJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveListScenarioGroupsProtobuf(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 *agentSimulationServer) serveListScenarioGroupsJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "ListScenarioGroups")
	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(ScenarioGroup_List_Request)
	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.AgentSimulation.ListScenarioGroups
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *ScenarioGroup_List_Request) (*ScenarioGroup_List_Response, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ScenarioGroup_List_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ScenarioGroup_List_Request) when calling interceptor")
					}
					return s.AgentSimulation.ListScenarioGroups(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ScenarioGroup_List_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ScenarioGroup_List_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

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

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

	// Call service method
	var respContent *ScenarioGroup_List_Response
	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 *ScenarioGroup_List_Response and nil error while calling ListScenarioGroups. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	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 *agentSimulationServer) serveListScenarios(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.serveListScenariosJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveListScenariosProtobuf(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 *agentSimulationServer) serveListScenariosJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "ListScenarios")
	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(Scenario_List_Request)
	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.AgentSimulation.ListScenarios
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *Scenario_List_Request) (*Scenario_List_Response, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*Scenario_List_Request)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*Scenario_List_Request) when calling interceptor")
					}
					return s.AgentSimulation.ListScenarios(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*Scenario_List_Response)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*Scenario_List_Response) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

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

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

	// Call service method
	var respContent *Scenario_List_Response
	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 *Scenario_List_Response and nil error while calling ListScenarios. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	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 *agentSimulationServer) ServiceDescriptor() ([]byte, int) {
	return twirpFileDescriptor8, 0
}

func (s *agentSimulationServer) 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 *agentSimulationServer) PathPrefix() string {
	return baseServicePath(s.pathPrefix, "livekit", "AgentSimulation")
}

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