encode_decode.go

// Code generated by goa v3.24.1, DO NOT EDIT.
//
// survey HTTP client encoders and decoders
//
// Command:
// $ goa gen
// github.com/linuxfoundation/lfx-v2-survey-service/api/survey/v1/design

package client

import (
	"bytes"
	"context"
	"io"
	"net/http"
	"net/url"
	"strings"

	survey "github.com/linuxfoundation/lfx-v2-survey-service/gen/survey"
	goahttp "goa.design/goa/v3/http"
)

// BuildScheduleSurveyRequest instantiates a HTTP request object with method
// and path set to call the "survey" service "schedule_survey" endpoint
func (c *Client) BuildScheduleSurveyRequest(ctx context.Context, v any) (*http.Request, error) {
	u := &url.URL{Scheme: c.scheme, Host: c.host, Path: ScheduleSurveySurveyPath()}
	req, err := http.NewRequest("POST", u.String(), nil)
	if err != nil {
		return nil, goahttp.ErrInvalidURL("survey", "schedule_survey", u.String(), err)
	}
	if ctx != nil {
		req = req.WithContext(ctx)
	}

	return req, nil
}

// EncodeScheduleSurveyRequest returns an encoder for requests sent to the
// survey schedule_survey server.
func EncodeScheduleSurveyRequest(encoder func(*http.Request) goahttp.Encoder) func(*http.Request, any) error {
	return func(req *http.Request, v any) error {
		p, ok := v.(*survey.ScheduleSurveyPayload)
		if !ok {
			return goahttp.ErrInvalidType("survey", "schedule_survey", "*survey.ScheduleSurveyPayload", v)
		}
		if p.Token != nil {
			head := *p.Token
			if !strings.Contains(head, " ") {
				req.Header.Set("Authorization", "Bearer "+head)
			} else {
				req.Header.Set("Authorization", head)
			}
		}
		body := NewScheduleSurveyRequestBody(p)
		if err := encoder(req).Encode(&body); err != nil {
			return goahttp.ErrEncodingError("survey", "schedule_survey", err)
		}
		return nil
	}
}

// DecodeScheduleSurveyResponse returns a decoder for responses returned by the
// survey schedule_survey endpoint. restoreBody controls whether the response
// body should be restored after having been read.
// DecodeScheduleSurveyResponse may return the following errors:
//   - "BadRequest" (type *survey.BadRequestError): http.StatusBadRequest
//   - "Forbidden" (type *survey.ForbiddenError): http.StatusForbidden
//   - "InternalServerError" (type *survey.InternalServerError): http.StatusInternalServerError
//   - "ServiceUnavailable" (type *survey.ServiceUnavailableError): http.StatusServiceUnavailable
//   - "Unauthorized" (type *survey.UnauthorizedError): http.StatusUnauthorized
//   - error: internal error
func DecodeScheduleSurveyResponse(decoder func(*http.Response) goahttp.Decoder, restoreBody bool) func(*http.Response) (any, error) {
	return func(resp *http.Response) (any, error) {
		if restoreBody {
			b, err := io.ReadAll(resp.Body)
			if err != nil {
				return nil, err
			}
			resp.Body = io.NopCloser(bytes.NewBuffer(b))
			defer func() {
				resp.Body = io.NopCloser(bytes.NewBuffer(b))
			}()
		} else {
			defer resp.Body.Close()
		}
		switch resp.StatusCode {
		case http.StatusCreated:
			var (
				body ScheduleSurveyResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "schedule_survey", err)
			}
			err = ValidateScheduleSurveyResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "schedule_survey", err)
			}
			res := NewScheduleSurveySurveyScheduleResultCreated(&body)
			return res, nil
		case http.StatusBadRequest:
			var (
				body ScheduleSurveyBadRequestResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "schedule_survey", err)
			}
			err = ValidateScheduleSurveyBadRequestResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "schedule_survey", err)
			}
			return nil, NewScheduleSurveyBadRequest(&body)
		case http.StatusForbidden:
			var (
				body ScheduleSurveyForbiddenResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "schedule_survey", err)
			}
			err = ValidateScheduleSurveyForbiddenResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "schedule_survey", err)
			}
			return nil, NewScheduleSurveyForbidden(&body)
		case http.StatusInternalServerError:
			var (
				body ScheduleSurveyInternalServerErrorResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "schedule_survey", err)
			}
			err = ValidateScheduleSurveyInternalServerErrorResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "schedule_survey", err)
			}
			return nil, NewScheduleSurveyInternalServerError(&body)
		case http.StatusServiceUnavailable:
			var (
				body ScheduleSurveyServiceUnavailableResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "schedule_survey", err)
			}
			err = ValidateScheduleSurveyServiceUnavailableResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "schedule_survey", err)
			}
			return nil, NewScheduleSurveyServiceUnavailable(&body)
		case http.StatusUnauthorized:
			var (
				body ScheduleSurveyUnauthorizedResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "schedule_survey", err)
			}
			err = ValidateScheduleSurveyUnauthorizedResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "schedule_survey", err)
			}
			return nil, NewScheduleSurveyUnauthorized(&body)
		default:
			body, _ := io.ReadAll(resp.Body)
			return nil, goahttp.ErrInvalidResponse("survey", "schedule_survey", resp.StatusCode, string(body))
		}
	}
}

// BuildGetSurveyRequest instantiates a HTTP request object with method and
// path set to call the "survey" service "get_survey" endpoint
func (c *Client) BuildGetSurveyRequest(ctx context.Context, v any) (*http.Request, error) {
	var (
		surveyUID string
	)
	{
		p, ok := v.(*survey.GetSurveyPayload)
		if !ok {
			return nil, goahttp.ErrInvalidType("survey", "get_survey", "*survey.GetSurveyPayload", v)
		}
		surveyUID = p.SurveyUID
	}
	u := &url.URL{Scheme: c.scheme, Host: c.host, Path: GetSurveySurveyPath(surveyUID)}
	req, err := http.NewRequest("GET", u.String(), nil)
	if err != nil {
		return nil, goahttp.ErrInvalidURL("survey", "get_survey", u.String(), err)
	}
	if ctx != nil {
		req = req.WithContext(ctx)
	}

	return req, nil
}

// EncodeGetSurveyRequest returns an encoder for requests sent to the survey
// get_survey server.
func EncodeGetSurveyRequest(encoder func(*http.Request) goahttp.Encoder) func(*http.Request, any) error {
	return func(req *http.Request, v any) error {
		p, ok := v.(*survey.GetSurveyPayload)
		if !ok {
			return goahttp.ErrInvalidType("survey", "get_survey", "*survey.GetSurveyPayload", v)
		}
		if p.Token != nil {
			head := *p.Token
			if !strings.Contains(head, " ") {
				req.Header.Set("Authorization", "Bearer "+head)
			} else {
				req.Header.Set("Authorization", head)
			}
		}
		values := req.URL.Query()
		if p.ProjectUID != nil {
			values.Add("project_uid", *p.ProjectUID)
		}
		if p.ProjectUids != nil {
			values.Add("project_uids", *p.ProjectUids)
		}
		req.URL.RawQuery = values.Encode()
		return nil
	}
}

// DecodeGetSurveyResponse returns a decoder for responses returned by the
// survey get_survey endpoint. restoreBody controls whether the response body
// should be restored after having been read.
// DecodeGetSurveyResponse may return the following errors:
//   - "BadRequest" (type *survey.BadRequestError): http.StatusBadRequest
//   - "Forbidden" (type *survey.ForbiddenError): http.StatusForbidden
//   - "InternalServerError" (type *survey.InternalServerError): http.StatusInternalServerError
//   - "NotFound" (type *survey.NotFoundError): http.StatusNotFound
//   - "ServiceUnavailable" (type *survey.ServiceUnavailableError): http.StatusServiceUnavailable
//   - "Unauthorized" (type *survey.UnauthorizedError): http.StatusUnauthorized
//   - error: internal error
func DecodeGetSurveyResponse(decoder func(*http.Response) goahttp.Decoder, restoreBody bool) func(*http.Response) (any, error) {
	return func(resp *http.Response) (any, error) {
		if restoreBody {
			b, err := io.ReadAll(resp.Body)
			if err != nil {
				return nil, err
			}
			resp.Body = io.NopCloser(bytes.NewBuffer(b))
			defer func() {
				resp.Body = io.NopCloser(bytes.NewBuffer(b))
			}()
		} else {
			defer resp.Body.Close()
		}
		switch resp.StatusCode {
		case http.StatusOK:
			var (
				body GetSurveyResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "get_survey", err)
			}
			err = ValidateGetSurveyResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "get_survey", err)
			}
			res := NewGetSurveySurveyScheduleResultOK(&body)
			return res, nil
		case http.StatusBadRequest:
			var (
				body GetSurveyBadRequestResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "get_survey", err)
			}
			err = ValidateGetSurveyBadRequestResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "get_survey", err)
			}
			return nil, NewGetSurveyBadRequest(&body)
		case http.StatusForbidden:
			var (
				body GetSurveyForbiddenResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "get_survey", err)
			}
			err = ValidateGetSurveyForbiddenResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "get_survey", err)
			}
			return nil, NewGetSurveyForbidden(&body)
		case http.StatusInternalServerError:
			var (
				body GetSurveyInternalServerErrorResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "get_survey", err)
			}
			err = ValidateGetSurveyInternalServerErrorResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "get_survey", err)
			}
			return nil, NewGetSurveyInternalServerError(&body)
		case http.StatusNotFound:
			var (
				body GetSurveyNotFoundResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "get_survey", err)
			}
			err = ValidateGetSurveyNotFoundResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "get_survey", err)
			}
			return nil, NewGetSurveyNotFound(&body)
		case http.StatusServiceUnavailable:
			var (
				body GetSurveyServiceUnavailableResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "get_survey", err)
			}
			err = ValidateGetSurveyServiceUnavailableResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "get_survey", err)
			}
			return nil, NewGetSurveyServiceUnavailable(&body)
		case http.StatusUnauthorized:
			var (
				body GetSurveyUnauthorizedResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "get_survey", err)
			}
			err = ValidateGetSurveyUnauthorizedResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "get_survey", err)
			}
			return nil, NewGetSurveyUnauthorized(&body)
		default:
			body, _ := io.ReadAll(resp.Body)
			return nil, goahttp.ErrInvalidResponse("survey", "get_survey", resp.StatusCode, string(body))
		}
	}
}

// BuildUpdateSurveyRequest instantiates a HTTP request object with method and
// path set to call the "survey" service "update_survey" endpoint
func (c *Client) BuildUpdateSurveyRequest(ctx context.Context, v any) (*http.Request, error) {
	var (
		surveyUID string
	)
	{
		p, ok := v.(*survey.UpdateSurveyPayload)
		if !ok {
			return nil, goahttp.ErrInvalidType("survey", "update_survey", "*survey.UpdateSurveyPayload", v)
		}
		surveyUID = p.SurveyUID
	}
	u := &url.URL{Scheme: c.scheme, Host: c.host, Path: UpdateSurveySurveyPath(surveyUID)}
	req, err := http.NewRequest("PUT", u.String(), nil)
	if err != nil {
		return nil, goahttp.ErrInvalidURL("survey", "update_survey", u.String(), err)
	}
	if ctx != nil {
		req = req.WithContext(ctx)
	}

	return req, nil
}

// EncodeUpdateSurveyRequest returns an encoder for requests sent to the survey
// update_survey server.
func EncodeUpdateSurveyRequest(encoder func(*http.Request) goahttp.Encoder) func(*http.Request, any) error {
	return func(req *http.Request, v any) error {
		p, ok := v.(*survey.UpdateSurveyPayload)
		if !ok {
			return goahttp.ErrInvalidType("survey", "update_survey", "*survey.UpdateSurveyPayload", v)
		}
		if p.Token != nil {
			head := *p.Token
			if !strings.Contains(head, " ") {
				req.Header.Set("Authorization", "Bearer "+head)
			} else {
				req.Header.Set("Authorization", head)
			}
		}
		body := NewUpdateSurveyRequestBody(p)
		if err := encoder(req).Encode(&body); err != nil {
			return goahttp.ErrEncodingError("survey", "update_survey", err)
		}
		return nil
	}
}

// DecodeUpdateSurveyResponse returns a decoder for responses returned by the
// survey update_survey endpoint. restoreBody controls whether the response
// body should be restored after having been read.
// DecodeUpdateSurveyResponse may return the following errors:
//   - "BadRequest" (type *survey.BadRequestError): http.StatusBadRequest
//   - "Forbidden" (type *survey.ForbiddenError): http.StatusForbidden
//   - "InternalServerError" (type *survey.InternalServerError): http.StatusInternalServerError
//   - "NotFound" (type *survey.NotFoundError): http.StatusNotFound
//   - "ServiceUnavailable" (type *survey.ServiceUnavailableError): http.StatusServiceUnavailable
//   - "Unauthorized" (type *survey.UnauthorizedError): http.StatusUnauthorized
//   - error: internal error
func DecodeUpdateSurveyResponse(decoder func(*http.Response) goahttp.Decoder, restoreBody bool) func(*http.Response) (any, error) {
	return func(resp *http.Response) (any, error) {
		if restoreBody {
			b, err := io.ReadAll(resp.Body)
			if err != nil {
				return nil, err
			}
			resp.Body = io.NopCloser(bytes.NewBuffer(b))
			defer func() {
				resp.Body = io.NopCloser(bytes.NewBuffer(b))
			}()
		} else {
			defer resp.Body.Close()
		}
		switch resp.StatusCode {
		case http.StatusOK:
			var (
				body UpdateSurveyResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "update_survey", err)
			}
			err = ValidateUpdateSurveyResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "update_survey", err)
			}
			res := NewUpdateSurveySurveyScheduleResultOK(&body)
			return res, nil
		case http.StatusBadRequest:
			var (
				body UpdateSurveyBadRequestResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "update_survey", err)
			}
			err = ValidateUpdateSurveyBadRequestResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "update_survey", err)
			}
			return nil, NewUpdateSurveyBadRequest(&body)
		case http.StatusForbidden:
			var (
				body UpdateSurveyForbiddenResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "update_survey", err)
			}
			err = ValidateUpdateSurveyForbiddenResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "update_survey", err)
			}
			return nil, NewUpdateSurveyForbidden(&body)
		case http.StatusInternalServerError:
			var (
				body UpdateSurveyInternalServerErrorResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "update_survey", err)
			}
			err = ValidateUpdateSurveyInternalServerErrorResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "update_survey", err)
			}
			return nil, NewUpdateSurveyInternalServerError(&body)
		case http.StatusNotFound:
			var (
				body UpdateSurveyNotFoundResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "update_survey", err)
			}
			err = ValidateUpdateSurveyNotFoundResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "update_survey", err)
			}
			return nil, NewUpdateSurveyNotFound(&body)
		case http.StatusServiceUnavailable:
			var (
				body UpdateSurveyServiceUnavailableResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "update_survey", err)
			}
			err = ValidateUpdateSurveyServiceUnavailableResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "update_survey", err)
			}
			return nil, NewUpdateSurveyServiceUnavailable(&body)
		case http.StatusUnauthorized:
			var (
				body UpdateSurveyUnauthorizedResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "update_survey", err)
			}
			err = ValidateUpdateSurveyUnauthorizedResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "update_survey", err)
			}
			return nil, NewUpdateSurveyUnauthorized(&body)
		default:
			body, _ := io.ReadAll(resp.Body)
			return nil, goahttp.ErrInvalidResponse("survey", "update_survey", resp.StatusCode, string(body))
		}
	}
}

// BuildDeleteSurveyRequest instantiates a HTTP request object with method and
// path set to call the "survey" service "delete_survey" endpoint
func (c *Client) BuildDeleteSurveyRequest(ctx context.Context, v any) (*http.Request, error) {
	var (
		surveyUID string
	)
	{
		p, ok := v.(*survey.DeleteSurveyPayload)
		if !ok {
			return nil, goahttp.ErrInvalidType("survey", "delete_survey", "*survey.DeleteSurveyPayload", v)
		}
		surveyUID = p.SurveyUID
	}
	u := &url.URL{Scheme: c.scheme, Host: c.host, Path: DeleteSurveySurveyPath(surveyUID)}
	req, err := http.NewRequest("DELETE", u.String(), nil)
	if err != nil {
		return nil, goahttp.ErrInvalidURL("survey", "delete_survey", u.String(), err)
	}
	if ctx != nil {
		req = req.WithContext(ctx)
	}

	return req, nil
}

// EncodeDeleteSurveyRequest returns an encoder for requests sent to the survey
// delete_survey server.
func EncodeDeleteSurveyRequest(encoder func(*http.Request) goahttp.Encoder) func(*http.Request, any) error {
	return func(req *http.Request, v any) error {
		p, ok := v.(*survey.DeleteSurveyPayload)
		if !ok {
			return goahttp.ErrInvalidType("survey", "delete_survey", "*survey.DeleteSurveyPayload", v)
		}
		if p.Token != nil {
			head := *p.Token
			if !strings.Contains(head, " ") {
				req.Header.Set("Authorization", "Bearer "+head)
			} else {
				req.Header.Set("Authorization", head)
			}
		}
		return nil
	}
}

// DecodeDeleteSurveyResponse returns a decoder for responses returned by the
// survey delete_survey endpoint. restoreBody controls whether the response
// body should be restored after having been read.
// DecodeDeleteSurveyResponse may return the following errors:
//   - "BadRequest" (type *survey.BadRequestError): http.StatusBadRequest
//   - "Forbidden" (type *survey.ForbiddenError): http.StatusForbidden
//   - "InternalServerError" (type *survey.InternalServerError): http.StatusInternalServerError
//   - "NotFound" (type *survey.NotFoundError): http.StatusNotFound
//   - "ServiceUnavailable" (type *survey.ServiceUnavailableError): http.StatusServiceUnavailable
//   - "Unauthorized" (type *survey.UnauthorizedError): http.StatusUnauthorized
//   - error: internal error
func DecodeDeleteSurveyResponse(decoder func(*http.Response) goahttp.Decoder, restoreBody bool) func(*http.Response) (any, error) {
	return func(resp *http.Response) (any, error) {
		if restoreBody {
			b, err := io.ReadAll(resp.Body)
			if err != nil {
				return nil, err
			}
			resp.Body = io.NopCloser(bytes.NewBuffer(b))
			defer func() {
				resp.Body = io.NopCloser(bytes.NewBuffer(b))
			}()
		} else {
			defer resp.Body.Close()
		}
		switch resp.StatusCode {
		case http.StatusNoContent:
			return nil, nil
		case http.StatusBadRequest:
			var (
				body DeleteSurveyBadRequestResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "delete_survey", err)
			}
			err = ValidateDeleteSurveyBadRequestResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "delete_survey", err)
			}
			return nil, NewDeleteSurveyBadRequest(&body)
		case http.StatusForbidden:
			var (
				body DeleteSurveyForbiddenResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "delete_survey", err)
			}
			err = ValidateDeleteSurveyForbiddenResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "delete_survey", err)
			}
			return nil, NewDeleteSurveyForbidden(&body)
		case http.StatusInternalServerError:
			var (
				body DeleteSurveyInternalServerErrorResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "delete_survey", err)
			}
			err = ValidateDeleteSurveyInternalServerErrorResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "delete_survey", err)
			}
			return nil, NewDeleteSurveyInternalServerError(&body)
		case http.StatusNotFound:
			var (
				body DeleteSurveyNotFoundResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "delete_survey", err)
			}
			err = ValidateDeleteSurveyNotFoundResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "delete_survey", err)
			}
			return nil, NewDeleteSurveyNotFound(&body)
		case http.StatusServiceUnavailable:
			var (
				body DeleteSurveyServiceUnavailableResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "delete_survey", err)
			}
			err = ValidateDeleteSurveyServiceUnavailableResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "delete_survey", err)
			}
			return nil, NewDeleteSurveyServiceUnavailable(&body)
		case http.StatusUnauthorized:
			var (
				body DeleteSurveyUnauthorizedResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "delete_survey", err)
			}
			err = ValidateDeleteSurveyUnauthorizedResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "delete_survey", err)
			}
			return nil, NewDeleteSurveyUnauthorized(&body)
		default:
			body, _ := io.ReadAll(resp.Body)
			return nil, goahttp.ErrInvalidResponse("survey", "delete_survey", resp.StatusCode, string(body))
		}
	}
}

// BuildBulkResendSurveyRequest instantiates a HTTP request object with method
// and path set to call the "survey" service "bulk_resend_survey" endpoint
func (c *Client) BuildBulkResendSurveyRequest(ctx context.Context, v any) (*http.Request, error) {
	var (
		surveyUID string
	)
	{
		p, ok := v.(*survey.BulkResendSurveyPayload)
		if !ok {
			return nil, goahttp.ErrInvalidType("survey", "bulk_resend_survey", "*survey.BulkResendSurveyPayload", v)
		}
		surveyUID = p.SurveyUID
	}
	u := &url.URL{Scheme: c.scheme, Host: c.host, Path: BulkResendSurveySurveyPath(surveyUID)}
	req, err := http.NewRequest("POST", u.String(), nil)
	if err != nil {
		return nil, goahttp.ErrInvalidURL("survey", "bulk_resend_survey", u.String(), err)
	}
	if ctx != nil {
		req = req.WithContext(ctx)
	}

	return req, nil
}

// EncodeBulkResendSurveyRequest returns an encoder for requests sent to the
// survey bulk_resend_survey server.
func EncodeBulkResendSurveyRequest(encoder func(*http.Request) goahttp.Encoder) func(*http.Request, any) error {
	return func(req *http.Request, v any) error {
		p, ok := v.(*survey.BulkResendSurveyPayload)
		if !ok {
			return goahttp.ErrInvalidType("survey", "bulk_resend_survey", "*survey.BulkResendSurveyPayload", v)
		}
		if p.Token != nil {
			head := *p.Token
			if !strings.Contains(head, " ") {
				req.Header.Set("Authorization", "Bearer "+head)
			} else {
				req.Header.Set("Authorization", head)
			}
		}
		body := NewBulkResendSurveyRequestBody(p)
		if err := encoder(req).Encode(&body); err != nil {
			return goahttp.ErrEncodingError("survey", "bulk_resend_survey", err)
		}
		return nil
	}
}

// DecodeBulkResendSurveyResponse returns a decoder for responses returned by
// the survey bulk_resend_survey endpoint. restoreBody controls whether the
// response body should be restored after having been read.
// DecodeBulkResendSurveyResponse may return the following errors:
//   - "BadRequest" (type *survey.BadRequestError): http.StatusBadRequest
//   - "Forbidden" (type *survey.ForbiddenError): http.StatusForbidden
//   - "InternalServerError" (type *survey.InternalServerError): http.StatusInternalServerError
//   - "NotFound" (type *survey.NotFoundError): http.StatusNotFound
//   - "ServiceUnavailable" (type *survey.ServiceUnavailableError): http.StatusServiceUnavailable
//   - "Unauthorized" (type *survey.UnauthorizedError): http.StatusUnauthorized
//   - error: internal error
func DecodeBulkResendSurveyResponse(decoder func(*http.Response) goahttp.Decoder, restoreBody bool) func(*http.Response) (any, error) {
	return func(resp *http.Response) (any, error) {
		if restoreBody {
			b, err := io.ReadAll(resp.Body)
			if err != nil {
				return nil, err
			}
			resp.Body = io.NopCloser(bytes.NewBuffer(b))
			defer func() {
				resp.Body = io.NopCloser(bytes.NewBuffer(b))
			}()
		} else {
			defer resp.Body.Close()
		}
		switch resp.StatusCode {
		case http.StatusNoContent:
			return nil, nil
		case http.StatusBadRequest:
			var (
				body BulkResendSurveyBadRequestResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "bulk_resend_survey", err)
			}
			err = ValidateBulkResendSurveyBadRequestResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "bulk_resend_survey", err)
			}
			return nil, NewBulkResendSurveyBadRequest(&body)
		case http.StatusForbidden:
			var (
				body BulkResendSurveyForbiddenResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "bulk_resend_survey", err)
			}
			err = ValidateBulkResendSurveyForbiddenResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "bulk_resend_survey", err)
			}
			return nil, NewBulkResendSurveyForbidden(&body)
		case http.StatusInternalServerError:
			var (
				body BulkResendSurveyInternalServerErrorResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "bulk_resend_survey", err)
			}
			err = ValidateBulkResendSurveyInternalServerErrorResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "bulk_resend_survey", err)
			}
			return nil, NewBulkResendSurveyInternalServerError(&body)
		case http.StatusNotFound:
			var (
				body BulkResendSurveyNotFoundResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "bulk_resend_survey", err)
			}
			err = ValidateBulkResendSurveyNotFoundResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "bulk_resend_survey", err)
			}
			return nil, NewBulkResendSurveyNotFound(&body)
		case http.StatusServiceUnavailable:
			var (
				body BulkResendSurveyServiceUnavailableResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "bulk_resend_survey", err)
			}
			err = ValidateBulkResendSurveyServiceUnavailableResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "bulk_resend_survey", err)
			}
			return nil, NewBulkResendSurveyServiceUnavailable(&body)
		case http.StatusUnauthorized:
			var (
				body BulkResendSurveyUnauthorizedResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "bulk_resend_survey", err)
			}
			err = ValidateBulkResendSurveyUnauthorizedResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "bulk_resend_survey", err)
			}
			return nil, NewBulkResendSurveyUnauthorized(&body)
		default:
			body, _ := io.ReadAll(resp.Body)
			return nil, goahttp.ErrInvalidResponse("survey", "bulk_resend_survey", resp.StatusCode, string(body))
		}
	}
}

// BuildPreviewSendSurveyRequest instantiates a HTTP request object with method
// and path set to call the "survey" service "preview_send_survey" endpoint
func (c *Client) BuildPreviewSendSurveyRequest(ctx context.Context, v any) (*http.Request, error) {
	var (
		surveyUID string
	)
	{
		p, ok := v.(*survey.PreviewSendSurveyPayload)
		if !ok {
			return nil, goahttp.ErrInvalidType("survey", "preview_send_survey", "*survey.PreviewSendSurveyPayload", v)
		}
		surveyUID = p.SurveyUID
	}
	u := &url.URL{Scheme: c.scheme, Host: c.host, Path: PreviewSendSurveySurveyPath(surveyUID)}
	req, err := http.NewRequest("GET", u.String(), nil)
	if err != nil {
		return nil, goahttp.ErrInvalidURL("survey", "preview_send_survey", u.String(), err)
	}
	if ctx != nil {
		req = req.WithContext(ctx)
	}

	return req, nil
}

// EncodePreviewSendSurveyRequest returns an encoder for requests sent to the
// survey preview_send_survey server.
func EncodePreviewSendSurveyRequest(encoder func(*http.Request) goahttp.Encoder) func(*http.Request, any) error {
	return func(req *http.Request, v any) error {
		p, ok := v.(*survey.PreviewSendSurveyPayload)
		if !ok {
			return goahttp.ErrInvalidType("survey", "preview_send_survey", "*survey.PreviewSendSurveyPayload", v)
		}
		if p.Token != nil {
			head := *p.Token
			if !strings.Contains(head, " ") {
				req.Header.Set("Authorization", "Bearer "+head)
			} else {
				req.Header.Set("Authorization", head)
			}
		}
		values := req.URL.Query()
		if p.CommitteeUID != nil {
			values.Add("committee_uid", *p.CommitteeUID)
		}
		req.URL.RawQuery = values.Encode()
		return nil
	}
}

// DecodePreviewSendSurveyResponse returns a decoder for responses returned by
// the survey preview_send_survey endpoint. restoreBody controls whether the
// response body should be restored after having been read.
// DecodePreviewSendSurveyResponse may return the following errors:
//   - "BadRequest" (type *survey.BadRequestError): http.StatusBadRequest
//   - "Forbidden" (type *survey.ForbiddenError): http.StatusForbidden
//   - "InternalServerError" (type *survey.InternalServerError): http.StatusInternalServerError
//   - "NotFound" (type *survey.NotFoundError): http.StatusNotFound
//   - "ServiceUnavailable" (type *survey.ServiceUnavailableError): http.StatusServiceUnavailable
//   - "Unauthorized" (type *survey.UnauthorizedError): http.StatusUnauthorized
//   - error: internal error
func DecodePreviewSendSurveyResponse(decoder func(*http.Response) goahttp.Decoder, restoreBody bool) func(*http.Response) (any, error) {
	return func(resp *http.Response) (any, error) {
		if restoreBody {
			b, err := io.ReadAll(resp.Body)
			if err != nil {
				return nil, err
			}
			resp.Body = io.NopCloser(bytes.NewBuffer(b))
			defer func() {
				resp.Body = io.NopCloser(bytes.NewBuffer(b))
			}()
		} else {
			defer resp.Body.Close()
		}
		switch resp.StatusCode {
		case http.StatusOK:
			var (
				body PreviewSendSurveyResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "preview_send_survey", err)
			}
			err = ValidatePreviewSendSurveyResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "preview_send_survey", err)
			}
			res := NewPreviewSendSurveyPreviewSendResultOK(&body)
			return res, nil
		case http.StatusBadRequest:
			var (
				body PreviewSendSurveyBadRequestResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "preview_send_survey", err)
			}
			err = ValidatePreviewSendSurveyBadRequestResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "preview_send_survey", err)
			}
			return nil, NewPreviewSendSurveyBadRequest(&body)
		case http.StatusForbidden:
			var (
				body PreviewSendSurveyForbiddenResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "preview_send_survey", err)
			}
			err = ValidatePreviewSendSurveyForbiddenResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "preview_send_survey", err)
			}
			return nil, NewPreviewSendSurveyForbidden(&body)
		case http.StatusInternalServerError:
			var (
				body PreviewSendSurveyInternalServerErrorResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "preview_send_survey", err)
			}
			err = ValidatePreviewSendSurveyInternalServerErrorResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "preview_send_survey", err)
			}
			return nil, NewPreviewSendSurveyInternalServerError(&body)
		case http.StatusNotFound:
			var (
				body PreviewSendSurveyNotFoundResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "preview_send_survey", err)
			}
			err = ValidatePreviewSendSurveyNotFoundResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "preview_send_survey", err)
			}
			return nil, NewPreviewSendSurveyNotFound(&body)
		case http.StatusServiceUnavailable:
			var (
				body PreviewSendSurveyServiceUnavailableResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "preview_send_survey", err)
			}
			err = ValidatePreviewSendSurveyServiceUnavailableResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "preview_send_survey", err)
			}
			return nil, NewPreviewSendSurveyServiceUnavailable(&body)
		case http.StatusUnauthorized:
			var (
				body PreviewSendSurveyUnauthorizedResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "preview_send_survey", err)
			}
			err = ValidatePreviewSendSurveyUnauthorizedResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "preview_send_survey", err)
			}
			return nil, NewPreviewSendSurveyUnauthorized(&body)
		default:
			body, _ := io.ReadAll(resp.Body)
			return nil, goahttp.ErrInvalidResponse("survey", "preview_send_survey", resp.StatusCode, string(body))
		}
	}
}

// BuildSendMissingRecipientsRequest instantiates a HTTP request object with
// method and path set to call the "survey" service "send_missing_recipients"
// endpoint
func (c *Client) BuildSendMissingRecipientsRequest(ctx context.Context, v any) (*http.Request, error) {
	var (
		surveyUID string
	)
	{
		p, ok := v.(*survey.SendMissingRecipientsPayload)
		if !ok {
			return nil, goahttp.ErrInvalidType("survey", "send_missing_recipients", "*survey.SendMissingRecipientsPayload", v)
		}
		surveyUID = p.SurveyUID
	}
	u := &url.URL{Scheme: c.scheme, Host: c.host, Path: SendMissingRecipientsSurveyPath(surveyUID)}
	req, err := http.NewRequest("POST", u.String(), nil)
	if err != nil {
		return nil, goahttp.ErrInvalidURL("survey", "send_missing_recipients", u.String(), err)
	}
	if ctx != nil {
		req = req.WithContext(ctx)
	}

	return req, nil
}

// EncodeSendMissingRecipientsRequest returns an encoder for requests sent to
// the survey send_missing_recipients server.
func EncodeSendMissingRecipientsRequest(encoder func(*http.Request) goahttp.Encoder) func(*http.Request, any) error {
	return func(req *http.Request, v any) error {
		p, ok := v.(*survey.SendMissingRecipientsPayload)
		if !ok {
			return goahttp.ErrInvalidType("survey", "send_missing_recipients", "*survey.SendMissingRecipientsPayload", v)
		}
		if p.Token != nil {
			head := *p.Token
			if !strings.Contains(head, " ") {
				req.Header.Set("Authorization", "Bearer "+head)
			} else {
				req.Header.Set("Authorization", head)
			}
		}
		values := req.URL.Query()
		if p.CommitteeUID != nil {
			values.Add("committee_uid", *p.CommitteeUID)
		}
		req.URL.RawQuery = values.Encode()
		return nil
	}
}

// DecodeSendMissingRecipientsResponse returns a decoder for responses returned
// by the survey send_missing_recipients endpoint. restoreBody controls whether
// the response body should be restored after having been read.
// DecodeSendMissingRecipientsResponse may return the following errors:
//   - "BadRequest" (type *survey.BadRequestError): http.StatusBadRequest
//   - "Forbidden" (type *survey.ForbiddenError): http.StatusForbidden
//   - "InternalServerError" (type *survey.InternalServerError): http.StatusInternalServerError
//   - "NotFound" (type *survey.NotFoundError): http.StatusNotFound
//   - "ServiceUnavailable" (type *survey.ServiceUnavailableError): http.StatusServiceUnavailable
//   - "Unauthorized" (type *survey.UnauthorizedError): http.StatusUnauthorized
//   - error: internal error
func DecodeSendMissingRecipientsResponse(decoder func(*http.Response) goahttp.Decoder, restoreBody bool) func(*http.Response) (any, error) {
	return func(resp *http.Response) (any, error) {
		if restoreBody {
			b, err := io.ReadAll(resp.Body)
			if err != nil {
				return nil, err
			}
			resp.Body = io.NopCloser(bytes.NewBuffer(b))
			defer func() {
				resp.Body = io.NopCloser(bytes.NewBuffer(b))
			}()
		} else {
			defer resp.Body.Close()
		}
		switch resp.StatusCode {
		case http.StatusNoContent:
			return nil, nil
		case http.StatusBadRequest:
			var (
				body SendMissingRecipientsBadRequestResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "send_missing_recipients", err)
			}
			err = ValidateSendMissingRecipientsBadRequestResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "send_missing_recipients", err)
			}
			return nil, NewSendMissingRecipientsBadRequest(&body)
		case http.StatusForbidden:
			var (
				body SendMissingRecipientsForbiddenResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "send_missing_recipients", err)
			}
			err = ValidateSendMissingRecipientsForbiddenResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "send_missing_recipients", err)
			}
			return nil, NewSendMissingRecipientsForbidden(&body)
		case http.StatusInternalServerError:
			var (
				body SendMissingRecipientsInternalServerErrorResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "send_missing_recipients", err)
			}
			err = ValidateSendMissingRecipientsInternalServerErrorResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "send_missing_recipients", err)
			}
			return nil, NewSendMissingRecipientsInternalServerError(&body)
		case http.StatusNotFound:
			var (
				body SendMissingRecipientsNotFoundResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "send_missing_recipients", err)
			}
			err = ValidateSendMissingRecipientsNotFoundResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "send_missing_recipients", err)
			}
			return nil, NewSendMissingRecipientsNotFound(&body)
		case http.StatusServiceUnavailable:
			var (
				body SendMissingRecipientsServiceUnavailableResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "send_missing_recipients", err)
			}
			err = ValidateSendMissingRecipientsServiceUnavailableResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "send_missing_recipients", err)
			}
			return nil, NewSendMissingRecipientsServiceUnavailable(&body)
		case http.StatusUnauthorized:
			var (
				body SendMissingRecipientsUnauthorizedResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "send_missing_recipients", err)
			}
			err = ValidateSendMissingRecipientsUnauthorizedResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "send_missing_recipients", err)
			}
			return nil, NewSendMissingRecipientsUnauthorized(&body)
		default:
			body, _ := io.ReadAll(resp.Body)
			return nil, goahttp.ErrInvalidResponse("survey", "send_missing_recipients", resp.StatusCode, string(body))
		}
	}
}

// BuildDeleteSurveyResponseRequest instantiates a HTTP request object with
// method and path set to call the "survey" service "delete_survey_response"
// endpoint
func (c *Client) BuildDeleteSurveyResponseRequest(ctx context.Context, v any) (*http.Request, error) {
	var (
		surveyUID  string
		responseID string
	)
	{
		p, ok := v.(*survey.DeleteSurveyResponsePayload)
		if !ok {
			return nil, goahttp.ErrInvalidType("survey", "delete_survey_response", "*survey.DeleteSurveyResponsePayload", v)
		}
		surveyUID = p.SurveyUID
		responseID = p.ResponseID
	}
	u := &url.URL{Scheme: c.scheme, Host: c.host, Path: DeleteSurveyResponseSurveyPath(surveyUID, responseID)}
	req, err := http.NewRequest("DELETE", u.String(), nil)
	if err != nil {
		return nil, goahttp.ErrInvalidURL("survey", "delete_survey_response", u.String(), err)
	}
	if ctx != nil {
		req = req.WithContext(ctx)
	}

	return req, nil
}

// EncodeDeleteSurveyResponseRequest returns an encoder for requests sent to
// the survey delete_survey_response server.
func EncodeDeleteSurveyResponseRequest(encoder func(*http.Request) goahttp.Encoder) func(*http.Request, any) error {
	return func(req *http.Request, v any) error {
		p, ok := v.(*survey.DeleteSurveyResponsePayload)
		if !ok {
			return goahttp.ErrInvalidType("survey", "delete_survey_response", "*survey.DeleteSurveyResponsePayload", v)
		}
		if p.Token != nil {
			head := *p.Token
			if !strings.Contains(head, " ") {
				req.Header.Set("Authorization", "Bearer "+head)
			} else {
				req.Header.Set("Authorization", head)
			}
		}
		return nil
	}
}

// DecodeDeleteSurveyResponseResponse returns a decoder for responses returned
// by the survey delete_survey_response endpoint. restoreBody controls whether
// the response body should be restored after having been read.
// DecodeDeleteSurveyResponseResponse may return the following errors:
//   - "BadRequest" (type *survey.BadRequestError): http.StatusBadRequest
//   - "Forbidden" (type *survey.ForbiddenError): http.StatusForbidden
//   - "InternalServerError" (type *survey.InternalServerError): http.StatusInternalServerError
//   - "NotFound" (type *survey.NotFoundError): http.StatusNotFound
//   - "ServiceUnavailable" (type *survey.ServiceUnavailableError): http.StatusServiceUnavailable
//   - "Unauthorized" (type *survey.UnauthorizedError): http.StatusUnauthorized
//   - error: internal error
func DecodeDeleteSurveyResponseResponse(decoder func(*http.Response) goahttp.Decoder, restoreBody bool) func(*http.Response) (any, error) {
	return func(resp *http.Response) (any, error) {
		if restoreBody {
			b, err := io.ReadAll(resp.Body)
			if err != nil {
				return nil, err
			}
			resp.Body = io.NopCloser(bytes.NewBuffer(b))
			defer func() {
				resp.Body = io.NopCloser(bytes.NewBuffer(b))
			}()
		} else {
			defer resp.Body.Close()
		}
		switch resp.StatusCode {
		case http.StatusNoContent:
			return nil, nil
		case http.StatusBadRequest:
			var (
				body DeleteSurveyResponseBadRequestResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "delete_survey_response", err)
			}
			err = ValidateDeleteSurveyResponseBadRequestResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "delete_survey_response", err)
			}
			return nil, NewDeleteSurveyResponseBadRequest(&body)
		case http.StatusForbidden:
			var (
				body DeleteSurveyResponseForbiddenResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "delete_survey_response", err)
			}
			err = ValidateDeleteSurveyResponseForbiddenResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "delete_survey_response", err)
			}
			return nil, NewDeleteSurveyResponseForbidden(&body)
		case http.StatusInternalServerError:
			var (
				body DeleteSurveyResponseInternalServerErrorResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "delete_survey_response", err)
			}
			err = ValidateDeleteSurveyResponseInternalServerErrorResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "delete_survey_response", err)
			}
			return nil, NewDeleteSurveyResponseInternalServerError(&body)
		case http.StatusNotFound:
			var (
				body DeleteSurveyResponseNotFoundResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "delete_survey_response", err)
			}
			err = ValidateDeleteSurveyResponseNotFoundResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "delete_survey_response", err)
			}
			return nil, NewDeleteSurveyResponseNotFound(&body)
		case http.StatusServiceUnavailable:
			var (
				body DeleteSurveyResponseServiceUnavailableResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "delete_survey_response", err)
			}
			err = ValidateDeleteSurveyResponseServiceUnavailableResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "delete_survey_response", err)
			}
			return nil, NewDeleteSurveyResponseServiceUnavailable(&body)
		case http.StatusUnauthorized:
			var (
				body DeleteSurveyResponseUnauthorizedResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "delete_survey_response", err)
			}
			err = ValidateDeleteSurveyResponseUnauthorizedResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "delete_survey_response", err)
			}
			return nil, NewDeleteSurveyResponseUnauthorized(&body)
		default:
			body, _ := io.ReadAll(resp.Body)
			return nil, goahttp.ErrInvalidResponse("survey", "delete_survey_response", resp.StatusCode, string(body))
		}
	}
}

// BuildResendSurveyResponseRequest instantiates a HTTP request object with
// method and path set to call the "survey" service "resend_survey_response"
// endpoint
func (c *Client) BuildResendSurveyResponseRequest(ctx context.Context, v any) (*http.Request, error) {
	var (
		surveyUID  string
		responseID string
	)
	{
		p, ok := v.(*survey.ResendSurveyResponsePayload)
		if !ok {
			return nil, goahttp.ErrInvalidType("survey", "resend_survey_response", "*survey.ResendSurveyResponsePayload", v)
		}
		surveyUID = p.SurveyUID
		responseID = p.ResponseID
	}
	u := &url.URL{Scheme: c.scheme, Host: c.host, Path: ResendSurveyResponseSurveyPath(surveyUID, responseID)}
	req, err := http.NewRequest("POST", u.String(), nil)
	if err != nil {
		return nil, goahttp.ErrInvalidURL("survey", "resend_survey_response", u.String(), err)
	}
	if ctx != nil {
		req = req.WithContext(ctx)
	}

	return req, nil
}

// EncodeResendSurveyResponseRequest returns an encoder for requests sent to
// the survey resend_survey_response server.
func EncodeResendSurveyResponseRequest(encoder func(*http.Request) goahttp.Encoder) func(*http.Request, any) error {
	return func(req *http.Request, v any) error {
		p, ok := v.(*survey.ResendSurveyResponsePayload)
		if !ok {
			return goahttp.ErrInvalidType("survey", "resend_survey_response", "*survey.ResendSurveyResponsePayload", v)
		}
		if p.Token != nil {
			head := *p.Token
			if !strings.Contains(head, " ") {
				req.Header.Set("Authorization", "Bearer "+head)
			} else {
				req.Header.Set("Authorization", head)
			}
		}
		return nil
	}
}

// DecodeResendSurveyResponseResponse returns a decoder for responses returned
// by the survey resend_survey_response endpoint. restoreBody controls whether
// the response body should be restored after having been read.
// DecodeResendSurveyResponseResponse may return the following errors:
//   - "BadRequest" (type *survey.BadRequestError): http.StatusBadRequest
//   - "Forbidden" (type *survey.ForbiddenError): http.StatusForbidden
//   - "InternalServerError" (type *survey.InternalServerError): http.StatusInternalServerError
//   - "NotFound" (type *survey.NotFoundError): http.StatusNotFound
//   - "ServiceUnavailable" (type *survey.ServiceUnavailableError): http.StatusServiceUnavailable
//   - "Unauthorized" (type *survey.UnauthorizedError): http.StatusUnauthorized
//   - error: internal error
func DecodeResendSurveyResponseResponse(decoder func(*http.Response) goahttp.Decoder, restoreBody bool) func(*http.Response) (any, error) {
	return func(resp *http.Response) (any, error) {
		if restoreBody {
			b, err := io.ReadAll(resp.Body)
			if err != nil {
				return nil, err
			}
			resp.Body = io.NopCloser(bytes.NewBuffer(b))
			defer func() {
				resp.Body = io.NopCloser(bytes.NewBuffer(b))
			}()
		} else {
			defer resp.Body.Close()
		}
		switch resp.StatusCode {
		case http.StatusNoContent:
			return nil, nil
		case http.StatusBadRequest:
			var (
				body ResendSurveyResponseBadRequestResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "resend_survey_response", err)
			}
			err = ValidateResendSurveyResponseBadRequestResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "resend_survey_response", err)
			}
			return nil, NewResendSurveyResponseBadRequest(&body)
		case http.StatusForbidden:
			var (
				body ResendSurveyResponseForbiddenResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "resend_survey_response", err)
			}
			err = ValidateResendSurveyResponseForbiddenResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "resend_survey_response", err)
			}
			return nil, NewResendSurveyResponseForbidden(&body)
		case http.StatusInternalServerError:
			var (
				body ResendSurveyResponseInternalServerErrorResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "resend_survey_response", err)
			}
			err = ValidateResendSurveyResponseInternalServerErrorResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "resend_survey_response", err)
			}
			return nil, NewResendSurveyResponseInternalServerError(&body)
		case http.StatusNotFound:
			var (
				body ResendSurveyResponseNotFoundResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "resend_survey_response", err)
			}
			err = ValidateResendSurveyResponseNotFoundResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "resend_survey_response", err)
			}
			return nil, NewResendSurveyResponseNotFound(&body)
		case http.StatusServiceUnavailable:
			var (
				body ResendSurveyResponseServiceUnavailableResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "resend_survey_response", err)
			}
			err = ValidateResendSurveyResponseServiceUnavailableResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "resend_survey_response", err)
			}
			return nil, NewResendSurveyResponseServiceUnavailable(&body)
		case http.StatusUnauthorized:
			var (
				body ResendSurveyResponseUnauthorizedResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "resend_survey_response", err)
			}
			err = ValidateResendSurveyResponseUnauthorizedResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "resend_survey_response", err)
			}
			return nil, NewResendSurveyResponseUnauthorized(&body)
		default:
			body, _ := io.ReadAll(resp.Body)
			return nil, goahttp.ErrInvalidResponse("survey", "resend_survey_response", resp.StatusCode, string(body))
		}
	}
}

// BuildDeleteRecipientGroupRequest instantiates a HTTP request object with
// method and path set to call the "survey" service "delete_recipient_group"
// endpoint
func (c *Client) BuildDeleteRecipientGroupRequest(ctx context.Context, v any) (*http.Request, error) {
	var (
		surveyUID string
	)
	{
		p, ok := v.(*survey.DeleteRecipientGroupPayload)
		if !ok {
			return nil, goahttp.ErrInvalidType("survey", "delete_recipient_group", "*survey.DeleteRecipientGroupPayload", v)
		}
		surveyUID = p.SurveyUID
	}
	u := &url.URL{Scheme: c.scheme, Host: c.host, Path: DeleteRecipientGroupSurveyPath(surveyUID)}
	req, err := http.NewRequest("DELETE", u.String(), nil)
	if err != nil {
		return nil, goahttp.ErrInvalidURL("survey", "delete_recipient_group", u.String(), err)
	}
	if ctx != nil {
		req = req.WithContext(ctx)
	}

	return req, nil
}

// EncodeDeleteRecipientGroupRequest returns an encoder for requests sent to
// the survey delete_recipient_group server.
func EncodeDeleteRecipientGroupRequest(encoder func(*http.Request) goahttp.Encoder) func(*http.Request, any) error {
	return func(req *http.Request, v any) error {
		p, ok := v.(*survey.DeleteRecipientGroupPayload)
		if !ok {
			return goahttp.ErrInvalidType("survey", "delete_recipient_group", "*survey.DeleteRecipientGroupPayload", v)
		}
		if p.Token != nil {
			head := *p.Token
			if !strings.Contains(head, " ") {
				req.Header.Set("Authorization", "Bearer "+head)
			} else {
				req.Header.Set("Authorization", head)
			}
		}
		values := req.URL.Query()
		if p.CommitteeUID != nil {
			values.Add("committee_uid", *p.CommitteeUID)
		}
		if p.ProjectUID != nil {
			values.Add("project_uid", *p.ProjectUID)
		}
		if p.FoundationID != nil {
			values.Add("foundation_id", *p.FoundationID)
		}
		req.URL.RawQuery = values.Encode()
		return nil
	}
}

// DecodeDeleteRecipientGroupResponse returns a decoder for responses returned
// by the survey delete_recipient_group endpoint. restoreBody controls whether
// the response body should be restored after having been read.
// DecodeDeleteRecipientGroupResponse may return the following errors:
//   - "BadRequest" (type *survey.BadRequestError): http.StatusBadRequest
//   - "Forbidden" (type *survey.ForbiddenError): http.StatusForbidden
//   - "InternalServerError" (type *survey.InternalServerError): http.StatusInternalServerError
//   - "NotFound" (type *survey.NotFoundError): http.StatusNotFound
//   - "ServiceUnavailable" (type *survey.ServiceUnavailableError): http.StatusServiceUnavailable
//   - "Unauthorized" (type *survey.UnauthorizedError): http.StatusUnauthorized
//   - error: internal error
func DecodeDeleteRecipientGroupResponse(decoder func(*http.Response) goahttp.Decoder, restoreBody bool) func(*http.Response) (any, error) {
	return func(resp *http.Response) (any, error) {
		if restoreBody {
			b, err := io.ReadAll(resp.Body)
			if err != nil {
				return nil, err
			}
			resp.Body = io.NopCloser(bytes.NewBuffer(b))
			defer func() {
				resp.Body = io.NopCloser(bytes.NewBuffer(b))
			}()
		} else {
			defer resp.Body.Close()
		}
		switch resp.StatusCode {
		case http.StatusNoContent:
			return nil, nil
		case http.StatusBadRequest:
			var (
				body DeleteRecipientGroupBadRequestResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "delete_recipient_group", err)
			}
			err = ValidateDeleteRecipientGroupBadRequestResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "delete_recipient_group", err)
			}
			return nil, NewDeleteRecipientGroupBadRequest(&body)
		case http.StatusForbidden:
			var (
				body DeleteRecipientGroupForbiddenResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "delete_recipient_group", err)
			}
			err = ValidateDeleteRecipientGroupForbiddenResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "delete_recipient_group", err)
			}
			return nil, NewDeleteRecipientGroupForbidden(&body)
		case http.StatusInternalServerError:
			var (
				body DeleteRecipientGroupInternalServerErrorResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "delete_recipient_group", err)
			}
			err = ValidateDeleteRecipientGroupInternalServerErrorResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "delete_recipient_group", err)
			}
			return nil, NewDeleteRecipientGroupInternalServerError(&body)
		case http.StatusNotFound:
			var (
				body DeleteRecipientGroupNotFoundResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "delete_recipient_group", err)
			}
			err = ValidateDeleteRecipientGroupNotFoundResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "delete_recipient_group", err)
			}
			return nil, NewDeleteRecipientGroupNotFound(&body)
		case http.StatusServiceUnavailable:
			var (
				body DeleteRecipientGroupServiceUnavailableResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "delete_recipient_group", err)
			}
			err = ValidateDeleteRecipientGroupServiceUnavailableResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "delete_recipient_group", err)
			}
			return nil, NewDeleteRecipientGroupServiceUnavailable(&body)
		case http.StatusUnauthorized:
			var (
				body DeleteRecipientGroupUnauthorizedResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "delete_recipient_group", err)
			}
			err = ValidateDeleteRecipientGroupUnauthorizedResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "delete_recipient_group", err)
			}
			return nil, NewDeleteRecipientGroupUnauthorized(&body)
		default:
			body, _ := io.ReadAll(resp.Body)
			return nil, goahttp.ErrInvalidResponse("survey", "delete_recipient_group", resp.StatusCode, string(body))
		}
	}
}

// BuildCreateExclusionRequest instantiates a HTTP request object with method
// and path set to call the "survey" service "create_exclusion" endpoint
func (c *Client) BuildCreateExclusionRequest(ctx context.Context, v any) (*http.Request, error) {
	u := &url.URL{Scheme: c.scheme, Host: c.host, Path: CreateExclusionSurveyPath()}
	req, err := http.NewRequest("POST", u.String(), nil)
	if err != nil {
		return nil, goahttp.ErrInvalidURL("survey", "create_exclusion", u.String(), err)
	}
	if ctx != nil {
		req = req.WithContext(ctx)
	}

	return req, nil
}

// EncodeCreateExclusionRequest returns an encoder for requests sent to the
// survey create_exclusion server.
func EncodeCreateExclusionRequest(encoder func(*http.Request) goahttp.Encoder) func(*http.Request, any) error {
	return func(req *http.Request, v any) error {
		p, ok := v.(*survey.CreateExclusionPayload)
		if !ok {
			return goahttp.ErrInvalidType("survey", "create_exclusion", "*survey.CreateExclusionPayload", v)
		}
		if p.Token != nil {
			head := *p.Token
			if !strings.Contains(head, " ") {
				req.Header.Set("Authorization", "Bearer "+head)
			} else {
				req.Header.Set("Authorization", head)
			}
		}
		body := NewCreateExclusionRequestBody(p)
		if err := encoder(req).Encode(&body); err != nil {
			return goahttp.ErrEncodingError("survey", "create_exclusion", err)
		}
		return nil
	}
}

// DecodeCreateExclusionResponse returns a decoder for responses returned by
// the survey create_exclusion endpoint. restoreBody controls whether the
// response body should be restored after having been read.
// DecodeCreateExclusionResponse may return the following errors:
//   - "BadRequest" (type *survey.BadRequestError): http.StatusBadRequest
//   - "Forbidden" (type *survey.ForbiddenError): http.StatusForbidden
//   - "InternalServerError" (type *survey.InternalServerError): http.StatusInternalServerError
//   - "Unauthorized" (type *survey.UnauthorizedError): http.StatusUnauthorized
//   - error: internal error
func DecodeCreateExclusionResponse(decoder func(*http.Response) goahttp.Decoder, restoreBody bool) func(*http.Response) (any, error) {
	return func(resp *http.Response) (any, error) {
		if restoreBody {
			b, err := io.ReadAll(resp.Body)
			if err != nil {
				return nil, err
			}
			resp.Body = io.NopCloser(bytes.NewBuffer(b))
			defer func() {
				resp.Body = io.NopCloser(bytes.NewBuffer(b))
			}()
		} else {
			defer resp.Body.Close()
		}
		switch resp.StatusCode {
		case http.StatusCreated:
			var (
				body CreateExclusionResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "create_exclusion", err)
			}
			err = ValidateCreateExclusionResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "create_exclusion", err)
			}
			res := NewCreateExclusionExclusionResultCreated(&body)
			return res, nil
		case http.StatusBadRequest:
			var (
				body CreateExclusionBadRequestResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "create_exclusion", err)
			}
			err = ValidateCreateExclusionBadRequestResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "create_exclusion", err)
			}
			return nil, NewCreateExclusionBadRequest(&body)
		case http.StatusForbidden:
			var (
				body CreateExclusionForbiddenResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "create_exclusion", err)
			}
			err = ValidateCreateExclusionForbiddenResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "create_exclusion", err)
			}
			return nil, NewCreateExclusionForbidden(&body)
		case http.StatusInternalServerError:
			var (
				body CreateExclusionInternalServerErrorResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "create_exclusion", err)
			}
			err = ValidateCreateExclusionInternalServerErrorResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "create_exclusion", err)
			}
			return nil, NewCreateExclusionInternalServerError(&body)
		case http.StatusUnauthorized:
			var (
				body CreateExclusionUnauthorizedResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "create_exclusion", err)
			}
			err = ValidateCreateExclusionUnauthorizedResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "create_exclusion", err)
			}
			return nil, NewCreateExclusionUnauthorized(&body)
		default:
			body, _ := io.ReadAll(resp.Body)
			return nil, goahttp.ErrInvalidResponse("survey", "create_exclusion", resp.StatusCode, string(body))
		}
	}
}

// BuildDeleteExclusionRequest instantiates a HTTP request object with method
// and path set to call the "survey" service "delete_exclusion" endpoint
func (c *Client) BuildDeleteExclusionRequest(ctx context.Context, v any) (*http.Request, error) {
	u := &url.URL{Scheme: c.scheme, Host: c.host, Path: DeleteExclusionSurveyPath()}
	req, err := http.NewRequest("DELETE", u.String(), nil)
	if err != nil {
		return nil, goahttp.ErrInvalidURL("survey", "delete_exclusion", u.String(), err)
	}
	if ctx != nil {
		req = req.WithContext(ctx)
	}

	return req, nil
}

// EncodeDeleteExclusionRequest returns an encoder for requests sent to the
// survey delete_exclusion server.
func EncodeDeleteExclusionRequest(encoder func(*http.Request) goahttp.Encoder) func(*http.Request, any) error {
	return func(req *http.Request, v any) error {
		p, ok := v.(*survey.DeleteExclusionPayload)
		if !ok {
			return goahttp.ErrInvalidType("survey", "delete_exclusion", "*survey.DeleteExclusionPayload", v)
		}
		if p.Token != nil {
			head := *p.Token
			if !strings.Contains(head, " ") {
				req.Header.Set("Authorization", "Bearer "+head)
			} else {
				req.Header.Set("Authorization", head)
			}
		}
		body := NewDeleteExclusionRequestBody(p)
		if err := encoder(req).Encode(&body); err != nil {
			return goahttp.ErrEncodingError("survey", "delete_exclusion", err)
		}
		return nil
	}
}

// DecodeDeleteExclusionResponse returns a decoder for responses returned by
// the survey delete_exclusion endpoint. restoreBody controls whether the
// response body should be restored after having been read.
// DecodeDeleteExclusionResponse may return the following errors:
//   - "BadRequest" (type *survey.BadRequestError): http.StatusBadRequest
//   - "Forbidden" (type *survey.ForbiddenError): http.StatusForbidden
//   - "InternalServerError" (type *survey.InternalServerError): http.StatusInternalServerError
//   - "Unauthorized" (type *survey.UnauthorizedError): http.StatusUnauthorized
//   - error: internal error
func DecodeDeleteExclusionResponse(decoder func(*http.Response) goahttp.Decoder, restoreBody bool) func(*http.Response) (any, error) {
	return func(resp *http.Response) (any, error) {
		if restoreBody {
			b, err := io.ReadAll(resp.Body)
			if err != nil {
				return nil, err
			}
			resp.Body = io.NopCloser(bytes.NewBuffer(b))
			defer func() {
				resp.Body = io.NopCloser(bytes.NewBuffer(b))
			}()
		} else {
			defer resp.Body.Close()
		}
		switch resp.StatusCode {
		case http.StatusNoContent:
			return nil, nil
		case http.StatusBadRequest:
			var (
				body DeleteExclusionBadRequestResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "delete_exclusion", err)
			}
			err = ValidateDeleteExclusionBadRequestResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "delete_exclusion", err)
			}
			return nil, NewDeleteExclusionBadRequest(&body)
		case http.StatusForbidden:
			var (
				body DeleteExclusionForbiddenResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "delete_exclusion", err)
			}
			err = ValidateDeleteExclusionForbiddenResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "delete_exclusion", err)
			}
			return nil, NewDeleteExclusionForbidden(&body)
		case http.StatusInternalServerError:
			var (
				body DeleteExclusionInternalServerErrorResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "delete_exclusion", err)
			}
			err = ValidateDeleteExclusionInternalServerErrorResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "delete_exclusion", err)
			}
			return nil, NewDeleteExclusionInternalServerError(&body)
		case http.StatusUnauthorized:
			var (
				body DeleteExclusionUnauthorizedResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "delete_exclusion", err)
			}
			err = ValidateDeleteExclusionUnauthorizedResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "delete_exclusion", err)
			}
			return nil, NewDeleteExclusionUnauthorized(&body)
		default:
			body, _ := io.ReadAll(resp.Body)
			return nil, goahttp.ErrInvalidResponse("survey", "delete_exclusion", resp.StatusCode, string(body))
		}
	}
}

// BuildGetExclusionRequest instantiates a HTTP request object with method and
// path set to call the "survey" service "get_exclusion" endpoint
func (c *Client) BuildGetExclusionRequest(ctx context.Context, v any) (*http.Request, error) {
	var (
		exclusionID string
	)
	{
		p, ok := v.(*survey.GetExclusionPayload)
		if !ok {
			return nil, goahttp.ErrInvalidType("survey", "get_exclusion", "*survey.GetExclusionPayload", v)
		}
		exclusionID = p.ExclusionID
	}
	u := &url.URL{Scheme: c.scheme, Host: c.host, Path: GetExclusionSurveyPath(exclusionID)}
	req, err := http.NewRequest("GET", u.String(), nil)
	if err != nil {
		return nil, goahttp.ErrInvalidURL("survey", "get_exclusion", u.String(), err)
	}
	if ctx != nil {
		req = req.WithContext(ctx)
	}

	return req, nil
}

// EncodeGetExclusionRequest returns an encoder for requests sent to the survey
// get_exclusion server.
func EncodeGetExclusionRequest(encoder func(*http.Request) goahttp.Encoder) func(*http.Request, any) error {
	return func(req *http.Request, v any) error {
		p, ok := v.(*survey.GetExclusionPayload)
		if !ok {
			return goahttp.ErrInvalidType("survey", "get_exclusion", "*survey.GetExclusionPayload", v)
		}
		if p.Token != nil {
			head := *p.Token
			if !strings.Contains(head, " ") {
				req.Header.Set("Authorization", "Bearer "+head)
			} else {
				req.Header.Set("Authorization", head)
			}
		}
		return nil
	}
}

// DecodeGetExclusionResponse returns a decoder for responses returned by the
// survey get_exclusion endpoint. restoreBody controls whether the response
// body should be restored after having been read.
// DecodeGetExclusionResponse may return the following errors:
//   - "BadRequest" (type *survey.BadRequestError): http.StatusBadRequest
//   - "Forbidden" (type *survey.ForbiddenError): http.StatusForbidden
//   - "InternalServerError" (type *survey.InternalServerError): http.StatusInternalServerError
//   - "NotFound" (type *survey.NotFoundError): http.StatusNotFound
//   - "Unauthorized" (type *survey.UnauthorizedError): http.StatusUnauthorized
//   - error: internal error
func DecodeGetExclusionResponse(decoder func(*http.Response) goahttp.Decoder, restoreBody bool) func(*http.Response) (any, error) {
	return func(resp *http.Response) (any, error) {
		if restoreBody {
			b, err := io.ReadAll(resp.Body)
			if err != nil {
				return nil, err
			}
			resp.Body = io.NopCloser(bytes.NewBuffer(b))
			defer func() {
				resp.Body = io.NopCloser(bytes.NewBuffer(b))
			}()
		} else {
			defer resp.Body.Close()
		}
		switch resp.StatusCode {
		case http.StatusOK:
			var (
				body GetExclusionResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "get_exclusion", err)
			}
			err = ValidateGetExclusionResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "get_exclusion", err)
			}
			res := NewGetExclusionExtendedExclusionResultOK(&body)
			return res, nil
		case http.StatusBadRequest:
			var (
				body GetExclusionBadRequestResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "get_exclusion", err)
			}
			err = ValidateGetExclusionBadRequestResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "get_exclusion", err)
			}
			return nil, NewGetExclusionBadRequest(&body)
		case http.StatusForbidden:
			var (
				body GetExclusionForbiddenResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "get_exclusion", err)
			}
			err = ValidateGetExclusionForbiddenResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "get_exclusion", err)
			}
			return nil, NewGetExclusionForbidden(&body)
		case http.StatusInternalServerError:
			var (
				body GetExclusionInternalServerErrorResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "get_exclusion", err)
			}
			err = ValidateGetExclusionInternalServerErrorResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "get_exclusion", err)
			}
			return nil, NewGetExclusionInternalServerError(&body)
		case http.StatusNotFound:
			var (
				body GetExclusionNotFoundResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "get_exclusion", err)
			}
			err = ValidateGetExclusionNotFoundResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "get_exclusion", err)
			}
			return nil, NewGetExclusionNotFound(&body)
		case http.StatusUnauthorized:
			var (
				body GetExclusionUnauthorizedResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "get_exclusion", err)
			}
			err = ValidateGetExclusionUnauthorizedResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "get_exclusion", err)
			}
			return nil, NewGetExclusionUnauthorized(&body)
		default:
			body, _ := io.ReadAll(resp.Body)
			return nil, goahttp.ErrInvalidResponse("survey", "get_exclusion", resp.StatusCode, string(body))
		}
	}
}

// BuildDeleteExclusionByIDRequest instantiates a HTTP request object with
// method and path set to call the "survey" service "delete_exclusion_by_id"
// endpoint
func (c *Client) BuildDeleteExclusionByIDRequest(ctx context.Context, v any) (*http.Request, error) {
	var (
		exclusionID string
	)
	{
		p, ok := v.(*survey.DeleteExclusionByIDPayload)
		if !ok {
			return nil, goahttp.ErrInvalidType("survey", "delete_exclusion_by_id", "*survey.DeleteExclusionByIDPayload", v)
		}
		exclusionID = p.ExclusionID
	}
	u := &url.URL{Scheme: c.scheme, Host: c.host, Path: DeleteExclusionByIDSurveyPath(exclusionID)}
	req, err := http.NewRequest("DELETE", u.String(), nil)
	if err != nil {
		return nil, goahttp.ErrInvalidURL("survey", "delete_exclusion_by_id", u.String(), err)
	}
	if ctx != nil {
		req = req.WithContext(ctx)
	}

	return req, nil
}

// EncodeDeleteExclusionByIDRequest returns an encoder for requests sent to the
// survey delete_exclusion_by_id server.
func EncodeDeleteExclusionByIDRequest(encoder func(*http.Request) goahttp.Encoder) func(*http.Request, any) error {
	return func(req *http.Request, v any) error {
		p, ok := v.(*survey.DeleteExclusionByIDPayload)
		if !ok {
			return goahttp.ErrInvalidType("survey", "delete_exclusion_by_id", "*survey.DeleteExclusionByIDPayload", v)
		}
		if p.Token != nil {
			head := *p.Token
			if !strings.Contains(head, " ") {
				req.Header.Set("Authorization", "Bearer "+head)
			} else {
				req.Header.Set("Authorization", head)
			}
		}
		return nil
	}
}

// DecodeDeleteExclusionByIDResponse returns a decoder for responses returned
// by the survey delete_exclusion_by_id endpoint. restoreBody controls whether
// the response body should be restored after having been read.
// DecodeDeleteExclusionByIDResponse may return the following errors:
//   - "BadRequest" (type *survey.BadRequestError): http.StatusBadRequest
//   - "Forbidden" (type *survey.ForbiddenError): http.StatusForbidden
//   - "InternalServerError" (type *survey.InternalServerError): http.StatusInternalServerError
//   - "Unauthorized" (type *survey.UnauthorizedError): http.StatusUnauthorized
//   - error: internal error
func DecodeDeleteExclusionByIDResponse(decoder func(*http.Response) goahttp.Decoder, restoreBody bool) func(*http.Response) (any, error) {
	return func(resp *http.Response) (any, error) {
		if restoreBody {
			b, err := io.ReadAll(resp.Body)
			if err != nil {
				return nil, err
			}
			resp.Body = io.NopCloser(bytes.NewBuffer(b))
			defer func() {
				resp.Body = io.NopCloser(bytes.NewBuffer(b))
			}()
		} else {
			defer resp.Body.Close()
		}
		switch resp.StatusCode {
		case http.StatusNoContent:
			return nil, nil
		case http.StatusBadRequest:
			var (
				body DeleteExclusionByIDBadRequestResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "delete_exclusion_by_id", err)
			}
			err = ValidateDeleteExclusionByIDBadRequestResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "delete_exclusion_by_id", err)
			}
			return nil, NewDeleteExclusionByIDBadRequest(&body)
		case http.StatusForbidden:
			var (
				body DeleteExclusionByIDForbiddenResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "delete_exclusion_by_id", err)
			}
			err = ValidateDeleteExclusionByIDForbiddenResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "delete_exclusion_by_id", err)
			}
			return nil, NewDeleteExclusionByIDForbidden(&body)
		case http.StatusInternalServerError:
			var (
				body DeleteExclusionByIDInternalServerErrorResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "delete_exclusion_by_id", err)
			}
			err = ValidateDeleteExclusionByIDInternalServerErrorResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "delete_exclusion_by_id", err)
			}
			return nil, NewDeleteExclusionByIDInternalServerError(&body)
		case http.StatusUnauthorized:
			var (
				body DeleteExclusionByIDUnauthorizedResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "delete_exclusion_by_id", err)
			}
			err = ValidateDeleteExclusionByIDUnauthorizedResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "delete_exclusion_by_id", err)
			}
			return nil, NewDeleteExclusionByIDUnauthorized(&body)
		default:
			body, _ := io.ReadAll(resp.Body)
			return nil, goahttp.ErrInvalidResponse("survey", "delete_exclusion_by_id", resp.StatusCode, string(body))
		}
	}
}

// BuildValidateEmailRequest instantiates a HTTP request object with method and
// path set to call the "survey" service "validate_email" endpoint
func (c *Client) BuildValidateEmailRequest(ctx context.Context, v any) (*http.Request, error) {
	u := &url.URL{Scheme: c.scheme, Host: c.host, Path: ValidateEmailSurveyPath()}
	req, err := http.NewRequest("POST", u.String(), nil)
	if err != nil {
		return nil, goahttp.ErrInvalidURL("survey", "validate_email", u.String(), err)
	}
	if ctx != nil {
		req = req.WithContext(ctx)
	}

	return req, nil
}

// EncodeValidateEmailRequest returns an encoder for requests sent to the
// survey validate_email server.
func EncodeValidateEmailRequest(encoder func(*http.Request) goahttp.Encoder) func(*http.Request, any) error {
	return func(req *http.Request, v any) error {
		p, ok := v.(*survey.ValidateEmailPayload)
		if !ok {
			return goahttp.ErrInvalidType("survey", "validate_email", "*survey.ValidateEmailPayload", v)
		}
		if p.Token != nil {
			head := *p.Token
			if !strings.Contains(head, " ") {
				req.Header.Set("Authorization", "Bearer "+head)
			} else {
				req.Header.Set("Authorization", head)
			}
		}
		body := NewValidateEmailRequestBody(p)
		if err := encoder(req).Encode(&body); err != nil {
			return goahttp.ErrEncodingError("survey", "validate_email", err)
		}
		return nil
	}
}

// DecodeValidateEmailResponse returns a decoder for responses returned by the
// survey validate_email endpoint. restoreBody controls whether the response
// body should be restored after having been read.
// DecodeValidateEmailResponse may return the following errors:
//   - "BadRequest" (type *survey.BadRequestError): http.StatusBadRequest
//   - "Forbidden" (type *survey.ForbiddenError): http.StatusForbidden
//   - "InternalServerError" (type *survey.InternalServerError): http.StatusInternalServerError
//   - "Unauthorized" (type *survey.UnauthorizedError): http.StatusUnauthorized
//   - error: internal error
func DecodeValidateEmailResponse(decoder func(*http.Response) goahttp.Decoder, restoreBody bool) func(*http.Response) (any, error) {
	return func(resp *http.Response) (any, error) {
		if restoreBody {
			b, err := io.ReadAll(resp.Body)
			if err != nil {
				return nil, err
			}
			resp.Body = io.NopCloser(bytes.NewBuffer(b))
			defer func() {
				resp.Body = io.NopCloser(bytes.NewBuffer(b))
			}()
		} else {
			defer resp.Body.Close()
		}
		switch resp.StatusCode {
		case http.StatusOK:
			var (
				body ValidateEmailResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "validate_email", err)
			}
			err = ValidateValidateEmailResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "validate_email", err)
			}
			res := NewValidateEmailResultOK(&body)
			return res, nil
		case http.StatusBadRequest:
			var (
				body ValidateEmailBadRequestResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "validate_email", err)
			}
			err = ValidateValidateEmailBadRequestResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "validate_email", err)
			}
			return nil, NewValidateEmailBadRequest(&body)
		case http.StatusForbidden:
			var (
				body ValidateEmailForbiddenResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "validate_email", err)
			}
			err = ValidateValidateEmailForbiddenResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "validate_email", err)
			}
			return nil, NewValidateEmailForbidden(&body)
		case http.StatusInternalServerError:
			var (
				body ValidateEmailInternalServerErrorResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "validate_email", err)
			}
			err = ValidateValidateEmailInternalServerErrorResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "validate_email", err)
			}
			return nil, NewValidateEmailInternalServerError(&body)
		case http.StatusUnauthorized:
			var (
				body ValidateEmailUnauthorizedResponseBody
				err  error
			)
			err = decoder(resp).Decode(&body)
			if err != nil {
				return nil, goahttp.ErrDecodingError("survey", "validate_email", err)
			}
			err = ValidateValidateEmailUnauthorizedResponseBody(&body)
			if err != nil {
				return nil, goahttp.ErrValidationError("survey", "validate_email", err)
			}
			return nil, NewValidateEmailUnauthorized(&body)
		default:
			body, _ := io.ReadAll(resp.Body)
			return nil, goahttp.ErrInvalidResponse("survey", "validate_email", resp.StatusCode, string(body))
		}
	}
}

// unmarshalSurveyCommitteeResponseBodyToSurveySurveyCommittee builds a value
// of type *survey.SurveyCommittee from a value of type
// *SurveyCommitteeResponseBody.
func unmarshalSurveyCommitteeResponseBodyToSurveySurveyCommittee(v *SurveyCommitteeResponseBody) *survey.SurveyCommittee {
	if v == nil {
		return nil
	}
	res := &survey.SurveyCommittee{
		CommitteeName:   v.CommitteeName,
		CommitteeUID:    v.CommitteeUID,
		ProjectUID:      v.ProjectUID,
		ProjectName:     v.ProjectName,
		SurveyURL:       v.SurveyURL,
		TotalRecipients: v.TotalRecipients,
		TotalResponses:  v.TotalResponses,
		NpsValue:        v.NpsValue,
	}

	return res
}

// unmarshalLFXProjectResponseBodyToSurveyLFXProject builds a value of type
// *survey.LFXProject from a value of type *LFXProjectResponseBody.
func unmarshalLFXProjectResponseBodyToSurveyLFXProject(v *LFXProjectResponseBody) *survey.LFXProject {
	if v == nil {
		return nil
	}
	res := &survey.LFXProject{
		ID:      *v.ID,
		Name:    *v.Name,
		Slug:    *v.Slug,
		Status:  *v.Status,
		LogoURL: v.LogoURL,
	}

	return res
}

// unmarshalExcludedCommitteeResponseBodyToSurveyExcludedCommittee builds a
// value of type *survey.ExcludedCommittee from a value of type
// *ExcludedCommitteeResponseBody.
func unmarshalExcludedCommitteeResponseBodyToSurveyExcludedCommittee(v *ExcludedCommitteeResponseBody) *survey.ExcludedCommittee {
	if v == nil {
		return nil
	}
	res := &survey.ExcludedCommittee{
		ProjectUID:        *v.ProjectUID,
		ProjectName:       *v.ProjectName,
		CommitteeUID:      *v.CommitteeUID,
		CommitteeName:     *v.CommitteeName,
		CommitteeCategory: *v.CommitteeCategory,
	}

	return res
}

// unmarshalITXPreviewRecipientResponseBodyToSurveyITXPreviewRecipient builds a
// value of type *survey.ITXPreviewRecipient from a value of type
// *ITXPreviewRecipientResponseBody.
func unmarshalITXPreviewRecipientResponseBodyToSurveyITXPreviewRecipient(v *ITXPreviewRecipientResponseBody) *survey.ITXPreviewRecipient {
	if v == nil {
		return nil
	}
	res := &survey.ITXPreviewRecipient{
		UserID:    *v.UserID,
		Name:      v.Name,
		FirstName: v.FirstName,
		LastName:  v.LastName,
		Username:  v.Username,
		Email:     *v.Email,
		Role:      v.Role,
	}

	return res
}

// unmarshalExclusionUserResponseBodyToSurveyExclusionUser builds a value of
// type *survey.ExclusionUser from a value of type *ExclusionUserResponseBody.
func unmarshalExclusionUserResponseBodyToSurveyExclusionUser(v *ExclusionUserResponseBody) *survey.ExclusionUser {
	if v == nil {
		return nil
	}
	res := &survey.ExclusionUser{
		ID:       v.ID,
		Username: v.Username,
	}
	if v.Emails != nil {
		res.Emails = make([]*survey.UserEmail, len(v.Emails))
		for i, val := range v.Emails {
			if val == nil {
				res.Emails[i] = nil
				continue
			}
			res.Emails[i] = unmarshalUserEmailResponseBodyToSurveyUserEmail(val)
		}
	}

	return res
}

// unmarshalUserEmailResponseBodyToSurveyUserEmail builds a value of type
// *survey.UserEmail from a value of type *UserEmailResponseBody.
func unmarshalUserEmailResponseBodyToSurveyUserEmail(v *UserEmailResponseBody) *survey.UserEmail {
	if v == nil {
		return nil
	}
	res := &survey.UserEmail{
		ID:           v.ID,
		EmailAddress: v.EmailAddress,
		IsPrimary:    v.IsPrimary,
	}

	return res
}