func GenerateBatchKeysParam(keyWriter restlicodec.ArrayWriter) (string, error) {
	writer := restlicodec.NewRestLiQueryParamsWriter()
	err := writer.WriteParams(func(paramNameWriter func(paramName string) restlicodec.Writer) error {
		return paramNameWriter("ids").WriteArray(keyWriter)
	})
	if err != nil {
		return "", err
	}
	return writer.Finalize(), nil
}
GenerateBatchKeysParam is intended for use by generated code when batch methods have no extra query parameters. Batch
methods with query parameters will have a standalone object that includes the "ids" parameter
package protocol
import (
	"context"
	"net/http"
	"net/url"
	"github.com/PapaCharlie/go-restli/protocol/restlicodec"
)
func (c *RestLiClient) DoGetRequest(ctx context.Context, url *url.URL, result restlicodec.Unmarshaler) (err error) {
	req, err := GetRequest(ctx, url, Method_get)
	if err != nil {
		return err
	}
	_, err = c.DoAndDecode(req, result)
	return err
}
type CreateResponseHasNoEntityHeaderError struct {
	Request  *http.Request
	Response *http.Response
}
func (c CreateResponseHasNoEntityHeaderError) Error() string {
	return "response from CREATE request did not specify a " + RestLiHeader_ID + " header"
}
func (c *RestLiClient) DoCreateRequest(
	ctx context.Context,
	url *url.URL,
	create restlicodec.Marshaler,
	readOnlyFields restlicodec.PathSpec,
	id restlicodec.Unmarshaler,
	returnEntity restlicodec.Unmarshaler,
) (err error) {
	req, err := JsonRequest(ctx, url, http.MethodPost, Method_create, create, readOnlyFields)
	if err != nil {
		return err
	}
	var res *http.Response
	if returnEntity != nil {
		res, err = c.DoAndDecode(req, returnEntity)
	} else {
		res, err = c.DoAndIgnore(req)
	}
	if err != nil {
		return err
	}
	if h := res.Header.Get(RestLiHeader_ID); len(h) > 0 {
		var reader restlicodec.Reader
		reader, err = restlicodec.NewRor2Reader(h)
		if err != nil {
			return err
		}
		err = id.UnmarshalRestLi(reader)
		if _, mfe := err.(*restlicodec.MissingRequiredFieldsError); mfe && !c.StrictResponseDeserialization {
			err = nil
		}
		if err != nil {
			return err
		}
	} else {
		return &CreateResponseHasNoEntityHeaderError{
			Request:  req,
			Response: res,
		}
	}
	return nil
}
func (c *RestLiClient) DoUpdateRequest(ctx context.Context, url *url.URL, update restlicodec.Marshaler) error {
	req, err := JsonRequest(ctx, url, http.MethodPut, Method_update, update, nil)
	if err != nil {
		return err
	}
	_, err = c.DoAndIgnore(req)
	return err
}
func (c *RestLiClient) DoPartialUpdateRequest(
	ctx context.Context,
	url *url.URL,
	patch restlicodec.Marshaler,
	createAndReadOnlyFields restlicodec.PathSpec,
) error {
	req, err := JsonRequest(ctx, url, http.MethodPost, Method_partial_update, &partialUpdateRequest{Patch: patch}, createAndReadOnlyFields)
	if err != nil {
		return err
	}
	_, err = c.DoAndIgnore(req)
	return err
}
func (c *RestLiClient) DoDeleteRequest(ctx context.Context, url *url.URL) error {
	req, err := DeleteRequest(ctx, url, Method_delete)
	if err != nil {
		return err
	}
	_, err = c.DoAndIgnore(req)
	return err
}
func (c *RestLiClient) DoFinderRequest(ctx context.Context, url *url.URL, elements restlicodec.ArrayReader) (total *int, err error) {
	req, err := GetRequest(ctx, url, Method_finder)
	if err != nil {
		return nil, err
	}
	results := restlicodec.UnmarshalerFunc(func(reader restlicodec.Reader) error {
		const elementsField = "elements"
		hasElements := false
		err = reader.ReadMap(func(reader restlicodec.Reader, key string) error {
			switch key {
			case elementsField:
				hasElements = true
				return reader.ReadArray(elements)
			case "paging":
				return reader.ReadMap(func(reader restlicodec.Reader, key string) (err error) {
					if key == "total" {
						var t int64
						t, err = reader.ReadInt64()
						if err != nil {
							return err
						}
						tInt := int(t)
						total = &tInt
					} else {
						err = reader.Skip()
					}
					return nil
				})
			default:
				return reader.Skip()
			}
		})
		if err != nil {
			return err
		}
		if !hasElements {
			reader.RecordMissingRequiredFields(map[string]struct{}{elementsField: {}})
		}
		return reader.CheckMissingFields()
	})
	_, err = c.DoAndDecode(req, results)
	return total, err
}
func (c *RestLiClient) DoActionRequest(ctx context.Context, url *url.URL, params restlicodec.Marshaler, results restlicodec.Unmarshaler) error {
	req, err := JsonRequest(ctx, url, http.MethodPost, Method_action, params, nil)
	if err != nil {
		return err
	}
	if results != nil {
		_, err = c.DoAndDecode(req, results)
	} else {
		_, err = c.DoAndIgnore(req)
	}
	return err
}