// Code generated by ogen, DO NOT EDIT.

package gen

import (
	"bytes"
	"io"
	"mime"
	"net/http"

	"github.com/go-faster/errors"
	"github.com/go-faster/jx"
	"github.com/ogen-go/ogen/ogenerrors"
	"github.com/ogen-go/ogen/validate"
)

func (s *Server) decodeDealsPostRequest(r *http.Request) (
	req *SafeDealRequest,
	rawBody []byte,
	close func() error,
	rerr error,
) {
	var closers []func() error
	close = func() error {
		var merr error
		// Close in reverse order, to match defer behavior.
		for i := len(closers) - 1; i >= 0; i-- {
			c := closers[i]
			merr = errors.Join(merr, c())
		}
		return merr
	}
	defer func() {
		if rerr != nil {
			rerr = errors.Join(rerr, close())
		}
	}()
	ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
	if err != nil {
		return req, rawBody, close, errors.Wrap(err, "parse media type")
	}
	switch {
	case ct == "application/json":
		if r.ContentLength == 0 {
			return req, rawBody, close, validate.ErrBodyRequired
		}
		buf, err := io.ReadAll(r.Body)
		defer func() {
			_ = r.Body.Close()
		}()
		if err != nil {
			return req, rawBody, close, err
		}

		// Reset the body to allow for downstream reading.
		r.Body = io.NopCloser(bytes.NewBuffer(buf))

		if len(buf) == 0 {
			return req, rawBody, close, validate.ErrBodyRequired
		}

		rawBody = append(rawBody, buf...)
		d := jx.DecodeBytes(buf)

		var request SafeDealRequest
		if err := func() error {
			if err := request.Decode(d); err != nil {
				return err
			}
			if err := d.Skip(); err != io.EOF {
				return errors.New("unexpected trailing data")
			}
			return nil
		}(); err != nil {
			err = &ogenerrors.DecodeBodyError{
				ContentType: ct,
				Body:        buf,
				Err:         err,
			}
			return req, rawBody, close, err
		}
		if err := func() error {
			if err := request.Validate(); err != nil {
				return err
			}
			return nil
		}(); err != nil {
			return req, rawBody, close, errors.Wrap(err, "validate")
		}
		return &request, rawBody, close, nil
	default:
		return req, rawBody, close, validate.InvalidContentType(ct)
	}
}

func (s *Server) decodePaymentMethodsPostRequest(r *http.Request) (
	req PaymentMethodsPostReq,
	rawBody []byte,
	close func() error,
	rerr error,
) {
	var closers []func() error
	close = func() error {
		var merr error
		// Close in reverse order, to match defer behavior.
		for i := len(closers) - 1; i >= 0; i-- {
			c := closers[i]
			merr = errors.Join(merr, c())
		}
		return merr
	}
	defer func() {
		if rerr != nil {
			rerr = errors.Join(rerr, close())
		}
	}()
	ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
	if err != nil {
		return req, rawBody, close, errors.Wrap(err, "parse media type")
	}
	switch {
	case ct == "application/json":
		if r.ContentLength == 0 {
			return req, rawBody, close, validate.ErrBodyRequired
		}
		buf, err := io.ReadAll(r.Body)
		defer func() {
			_ = r.Body.Close()
		}()
		if err != nil {
			return req, rawBody, close, err
		}

		// Reset the body to allow for downstream reading.
		r.Body = io.NopCloser(bytes.NewBuffer(buf))

		if len(buf) == 0 {
			return req, rawBody, close, validate.ErrBodyRequired
		}

		rawBody = append(rawBody, buf...)
		d := jx.DecodeBytes(buf)

		var request PaymentMethodsPostReq
		if err := func() error {
			if err := request.Decode(d); err != nil {
				return err
			}
			if err := d.Skip(); err != io.EOF {
				return errors.New("unexpected trailing data")
			}
			return nil
		}(); err != nil {
			err = &ogenerrors.DecodeBodyError{
				ContentType: ct,
				Body:        buf,
				Err:         err,
			}
			return req, rawBody, close, err
		}
		if err := func() error {
			if err := request.Validate(); err != nil {
				return err
			}
			return nil
		}(); err != nil {
			return req, rawBody, close, errors.Wrap(err, "validate")
		}
		return request, rawBody, close, nil
	default:
		return req, rawBody, close, validate.InvalidContentType(ct)
	}
}

func (s *Server) decodePaymentsPaymentIDCapturePostRequest(r *http.Request) (
	req *PaymentsPaymentIDCapturePostReq,
	rawBody []byte,
	close func() error,
	rerr error,
) {
	var closers []func() error
	close = func() error {
		var merr error
		// Close in reverse order, to match defer behavior.
		for i := len(closers) - 1; i >= 0; i-- {
			c := closers[i]
			merr = errors.Join(merr, c())
		}
		return merr
	}
	defer func() {
		if rerr != nil {
			rerr = errors.Join(rerr, close())
		}
	}()
	ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
	if err != nil {
		return req, rawBody, close, errors.Wrap(err, "parse media type")
	}
	switch {
	case ct == "application/json":
		if r.ContentLength == 0 {
			return req, rawBody, close, validate.ErrBodyRequired
		}
		buf, err := io.ReadAll(r.Body)
		defer func() {
			_ = r.Body.Close()
		}()
		if err != nil {
			return req, rawBody, close, err
		}

		// Reset the body to allow for downstream reading.
		r.Body = io.NopCloser(bytes.NewBuffer(buf))

		if len(buf) == 0 {
			return req, rawBody, close, validate.ErrBodyRequired
		}

		rawBody = append(rawBody, buf...)
		d := jx.DecodeBytes(buf)

		var request PaymentsPaymentIDCapturePostReq
		if err := func() error {
			if err := request.Decode(d); err != nil {
				return err
			}
			if err := d.Skip(); err != io.EOF {
				return errors.New("unexpected trailing data")
			}
			return nil
		}(); err != nil {
			err = &ogenerrors.DecodeBodyError{
				ContentType: ct,
				Body:        buf,
				Err:         err,
			}
			return req, rawBody, close, err
		}
		if err := func() error {
			if err := request.Validate(); err != nil {
				return err
			}
			return nil
		}(); err != nil {
			return req, rawBody, close, errors.Wrap(err, "validate")
		}
		return &request, rawBody, close, nil
	default:
		return req, rawBody, close, validate.InvalidContentType(ct)
	}
}

func (s *Server) decodePaymentsPostRequest(r *http.Request) (
	req *PaymentsPostReq,
	rawBody []byte,
	close func() error,
	rerr error,
) {
	var closers []func() error
	close = func() error {
		var merr error
		// Close in reverse order, to match defer behavior.
		for i := len(closers) - 1; i >= 0; i-- {
			c := closers[i]
			merr = errors.Join(merr, c())
		}
		return merr
	}
	defer func() {
		if rerr != nil {
			rerr = errors.Join(rerr, close())
		}
	}()
	ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
	if err != nil {
		return req, rawBody, close, errors.Wrap(err, "parse media type")
	}
	switch {
	case ct == "application/json":
		if r.ContentLength == 0 {
			return req, rawBody, close, validate.ErrBodyRequired
		}
		buf, err := io.ReadAll(r.Body)
		defer func() {
			_ = r.Body.Close()
		}()
		if err != nil {
			return req, rawBody, close, err
		}

		// Reset the body to allow for downstream reading.
		r.Body = io.NopCloser(bytes.NewBuffer(buf))

		if len(buf) == 0 {
			return req, rawBody, close, validate.ErrBodyRequired
		}

		rawBody = append(rawBody, buf...)
		d := jx.DecodeBytes(buf)

		var request PaymentsPostReq
		if err := func() error {
			if err := request.Decode(d); err != nil {
				return err
			}
			if err := d.Skip(); err != io.EOF {
				return errors.New("unexpected trailing data")
			}
			return nil
		}(); err != nil {
			err = &ogenerrors.DecodeBodyError{
				ContentType: ct,
				Body:        buf,
				Err:         err,
			}
			return req, rawBody, close, err
		}
		if err := func() error {
			if err := request.Validate(); err != nil {
				return err
			}
			return nil
		}(); err != nil {
			return req, rawBody, close, errors.Wrap(err, "validate")
		}
		return &request, rawBody, close, nil
	default:
		return req, rawBody, close, validate.InvalidContentType(ct)
	}
}

func (s *Server) decodePayoutsPostRequest(r *http.Request) (
	req *PayoutRequest,
	rawBody []byte,
	close func() error,
	rerr error,
) {
	var closers []func() error
	close = func() error {
		var merr error
		// Close in reverse order, to match defer behavior.
		for i := len(closers) - 1; i >= 0; i-- {
			c := closers[i]
			merr = errors.Join(merr, c())
		}
		return merr
	}
	defer func() {
		if rerr != nil {
			rerr = errors.Join(rerr, close())
		}
	}()
	ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
	if err != nil {
		return req, rawBody, close, errors.Wrap(err, "parse media type")
	}
	switch {
	case ct == "application/json":
		if r.ContentLength == 0 {
			return req, rawBody, close, validate.ErrBodyRequired
		}
		buf, err := io.ReadAll(r.Body)
		defer func() {
			_ = r.Body.Close()
		}()
		if err != nil {
			return req, rawBody, close, err
		}

		// Reset the body to allow for downstream reading.
		r.Body = io.NopCloser(bytes.NewBuffer(buf))

		if len(buf) == 0 {
			return req, rawBody, close, validate.ErrBodyRequired
		}

		rawBody = append(rawBody, buf...)
		d := jx.DecodeBytes(buf)

		var request PayoutRequest
		if err := func() error {
			if err := request.Decode(d); err != nil {
				return err
			}
			if err := d.Skip(); err != io.EOF {
				return errors.New("unexpected trailing data")
			}
			return nil
		}(); err != nil {
			err = &ogenerrors.DecodeBodyError{
				ContentType: ct,
				Body:        buf,
				Err:         err,
			}
			return req, rawBody, close, err
		}
		if err := func() error {
			if err := request.Validate(); err != nil {
				return err
			}
			return nil
		}(); err != nil {
			return req, rawBody, close, errors.Wrap(err, "validate")
		}
		return &request, rawBody, close, nil
	default:
		return req, rawBody, close, validate.InvalidContentType(ct)
	}
}

func (s *Server) decodePersonalDataPostRequest(r *http.Request) (
	req PersonalDataPostReq,
	rawBody []byte,
	close func() error,
	rerr error,
) {
	var closers []func() error
	close = func() error {
		var merr error
		// Close in reverse order, to match defer behavior.
		for i := len(closers) - 1; i >= 0; i-- {
			c := closers[i]
			merr = errors.Join(merr, c())
		}
		return merr
	}
	defer func() {
		if rerr != nil {
			rerr = errors.Join(rerr, close())
		}
	}()
	ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
	if err != nil {
		return req, rawBody, close, errors.Wrap(err, "parse media type")
	}
	switch {
	case ct == "application/json":
		if r.ContentLength == 0 {
			return req, rawBody, close, validate.ErrBodyRequired
		}
		buf, err := io.ReadAll(r.Body)
		defer func() {
			_ = r.Body.Close()
		}()
		if err != nil {
			return req, rawBody, close, err
		}

		// Reset the body to allow for downstream reading.
		r.Body = io.NopCloser(bytes.NewBuffer(buf))

		if len(buf) == 0 {
			return req, rawBody, close, validate.ErrBodyRequired
		}

		rawBody = append(rawBody, buf...)
		d := jx.DecodeBytes(buf)

		var request PersonalDataPostReq
		if err := func() error {
			if err := request.Decode(d); err != nil {
				return err
			}
			if err := d.Skip(); err != io.EOF {
				return errors.New("unexpected trailing data")
			}
			return nil
		}(); err != nil {
			err = &ogenerrors.DecodeBodyError{
				ContentType: ct,
				Body:        buf,
				Err:         err,
			}
			return req, rawBody, close, err
		}
		if err := func() error {
			if err := request.Validate(); err != nil {
				return err
			}
			return nil
		}(); err != nil {
			return req, rawBody, close, errors.Wrap(err, "validate")
		}
		return request, rawBody, close, nil
	default:
		return req, rawBody, close, validate.InvalidContentType(ct)
	}
}

func (s *Server) decodeReceiptsPostRequest(r *http.Request) (
	req PostReceiptData,
	rawBody []byte,
	close func() error,
	rerr error,
) {
	var closers []func() error
	close = func() error {
		var merr error
		// Close in reverse order, to match defer behavior.
		for i := len(closers) - 1; i >= 0; i-- {
			c := closers[i]
			merr = errors.Join(merr, c())
		}
		return merr
	}
	defer func() {
		if rerr != nil {
			rerr = errors.Join(rerr, close())
		}
	}()
	ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
	if err != nil {
		return req, rawBody, close, errors.Wrap(err, "parse media type")
	}
	switch {
	case ct == "application/json":
		if r.ContentLength == 0 {
			return req, rawBody, close, validate.ErrBodyRequired
		}
		buf, err := io.ReadAll(r.Body)
		defer func() {
			_ = r.Body.Close()
		}()
		if err != nil {
			return req, rawBody, close, err
		}

		// Reset the body to allow for downstream reading.
		r.Body = io.NopCloser(bytes.NewBuffer(buf))

		if len(buf) == 0 {
			return req, rawBody, close, validate.ErrBodyRequired
		}

		rawBody = append(rawBody, buf...)
		d := jx.DecodeBytes(buf)

		var request PostReceiptData
		if err := func() error {
			if err := request.Decode(d); err != nil {
				return err
			}
			if err := d.Skip(); err != io.EOF {
				return errors.New("unexpected trailing data")
			}
			return nil
		}(); err != nil {
			err = &ogenerrors.DecodeBodyError{
				ContentType: ct,
				Body:        buf,
				Err:         err,
			}
			return req, rawBody, close, err
		}
		return request, rawBody, close, nil
	default:
		return req, rawBody, close, validate.InvalidContentType(ct)
	}
}

func (s *Server) decodeRefundsPostRequest(r *http.Request) (
	req *RefundsPostReq,
	rawBody []byte,
	close func() error,
	rerr error,
) {
	var closers []func() error
	close = func() error {
		var merr error
		// Close in reverse order, to match defer behavior.
		for i := len(closers) - 1; i >= 0; i-- {
			c := closers[i]
			merr = errors.Join(merr, c())
		}
		return merr
	}
	defer func() {
		if rerr != nil {
			rerr = errors.Join(rerr, close())
		}
	}()
	ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
	if err != nil {
		return req, rawBody, close, errors.Wrap(err, "parse media type")
	}
	switch {
	case ct == "application/json":
		if r.ContentLength == 0 {
			return req, rawBody, close, validate.ErrBodyRequired
		}
		buf, err := io.ReadAll(r.Body)
		defer func() {
			_ = r.Body.Close()
		}()
		if err != nil {
			return req, rawBody, close, err
		}

		// Reset the body to allow for downstream reading.
		r.Body = io.NopCloser(bytes.NewBuffer(buf))

		if len(buf) == 0 {
			return req, rawBody, close, validate.ErrBodyRequired
		}

		rawBody = append(rawBody, buf...)
		d := jx.DecodeBytes(buf)

		var request RefundsPostReq
		if err := func() error {
			if err := request.Decode(d); err != nil {
				return err
			}
			if err := d.Skip(); err != io.EOF {
				return errors.New("unexpected trailing data")
			}
			return nil
		}(); err != nil {
			err = &ogenerrors.DecodeBodyError{
				ContentType: ct,
				Body:        buf,
				Err:         err,
			}
			return req, rawBody, close, err
		}
		if err := func() error {
			if err := request.Validate(); err != nil {
				return err
			}
			return nil
		}(); err != nil {
			return req, rawBody, close, errors.Wrap(err, "validate")
		}
		return &request, rawBody, close, nil
	default:
		return req, rawBody, close, validate.InvalidContentType(ct)
	}
}

func (s *Server) decodeWebhooksPostRequest(r *http.Request) (
	req *WebhooksPostReq,
	rawBody []byte,
	close func() error,
	rerr error,
) {
	var closers []func() error
	close = func() error {
		var merr error
		// Close in reverse order, to match defer behavior.
		for i := len(closers) - 1; i >= 0; i-- {
			c := closers[i]
			merr = errors.Join(merr, c())
		}
		return merr
	}
	defer func() {
		if rerr != nil {
			rerr = errors.Join(rerr, close())
		}
	}()
	ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
	if err != nil {
		return req, rawBody, close, errors.Wrap(err, "parse media type")
	}
	switch {
	case ct == "application/json":
		if r.ContentLength == 0 {
			return req, rawBody, close, validate.ErrBodyRequired
		}
		buf, err := io.ReadAll(r.Body)
		defer func() {
			_ = r.Body.Close()
		}()
		if err != nil {
			return req, rawBody, close, err
		}

		// Reset the body to allow for downstream reading.
		r.Body = io.NopCloser(bytes.NewBuffer(buf))

		if len(buf) == 0 {
			return req, rawBody, close, validate.ErrBodyRequired
		}

		rawBody = append(rawBody, buf...)
		d := jx.DecodeBytes(buf)

		var request WebhooksPostReq
		if err := func() error {
			if err := request.Decode(d); err != nil {
				return err
			}
			if err := d.Skip(); err != io.EOF {
				return errors.New("unexpected trailing data")
			}
			return nil
		}(); err != nil {
			err = &ogenerrors.DecodeBodyError{
				ContentType: ct,
				Body:        buf,
				Err:         err,
			}
			return req, rawBody, close, err
		}
		if err := func() error {
			if err := request.Validate(); err != nil {
				return err
			}
			return nil
		}(); err != nil {
			return req, rawBody, close, errors.Wrap(err, "validate")
		}
		return &request, rawBody, close, nil
	default:
		return req, rawBody, close, validate.InvalidContentType(ct)
	}
}