func (s *AnimeService) DeleteMyListItem(ctx context.Context, animeID int) (*Response, error) {
	u := fmt.Sprintf("anime/%d/my_list_status", animeID)
	req, err := s.client.NewRequest(http.MethodDelete, u)
	if err != nil {
		return nil, err
	}
	resp, err := s.client.Do(ctx, req, nil)
	if err != nil {
		return resp, err
	}
	return resp, nil
}
DeleteMyListItem deletes an anime from the user's list. If the anime does not
exist in the user's list, 404 Not Found error is returned.
package mal
import (
	"context"
	"fmt"
	"net/http"
	"net/url"
	"strconv"
	"strings"
	"time"
)
type AnimeListOption interface {
	animeListApply(v *url.Values)
}
type AnimeStatus string
const (
	AnimeStatusWatching AnimeStatus = "watching"
	AnimeStatusCompleted AnimeStatus = "completed"
	AnimeStatusOnHold AnimeStatus = "on_hold"
	AnimeStatusDropped AnimeStatus = "dropped"
	AnimeStatusPlanToWatch AnimeStatus = "plan_to_watch"
)
func (s AnimeStatus) animeListApply(v *url.Values)               { v.Set("status", string(s)) }
func (s AnimeStatus) updateMyAnimeListStatusApply(v *url.Values) { v.Set("status", string(s)) }
type SortAnimeList string
const (
	SortAnimeListByListScore SortAnimeList = "list_score"
	SortAnimeListByListUpdatedAt SortAnimeList = "list_updated_at"
	SortAnimeListByAnimeTitle SortAnimeList = "anime_title"
	SortAnimeListByAnimeStartDate SortAnimeList = "anime_start_date"
	SortAnimeListByAnimeID SortAnimeList = "anime_id"
)
func (s SortAnimeList) animeListApply(v *url.Values) { v.Set("sort", string(s)) }
type UserAnime struct {
	Anime  Anime           `json:"node"`
	Status AnimeListStatus `json:"list_status"`
}
type AnimeListStatus struct {
	Status             AnimeStatus `json:"status"`
	Score              int         `json:"score"`
	NumEpisodesWatched int         `json:"num_episodes_watched"`
	IsRewatching       bool        `json:"is_rewatching"`
	UpdatedAt          time.Time   `json:"updated_at"`
	Priority           int         `json:"priority"`
	NumTimesRewatched  int         `json:"num_times_rewatched"`
	RewatchValue       int         `json:"rewatch_value"`
	Tags               []string    `json:"tags"`
	Comments           string      `json:"comments"`
}
type animeList struct {
	Data   []UserAnime `json:"data"`
	Paging Paging      `json:"paging"`
}
func (a animeList) pagination() Paging { return a.Paging }
func (s *UserService) AnimeList(ctx context.Context, username string, options ...AnimeListOption) ([]UserAnime, *Response, error) {
	oo := make([]Option, len(options))
	for i := range options {
		oo[i] = optionFromAnimeListOption(options[i])
	}
	list := new(animeList)
	resp, err := s.client.list(ctx, fmt.Sprintf("users/%s/animelist", username), list, oo...)
	if err != nil {
		return nil, resp, err
	}
	return list.Data, resp, nil
}
func optionFromAnimeListOption(o AnimeListOption) optionFunc {
	return optionFunc(func(v *url.Values) {
		o.animeListApply(v)
	})
}
type UpdateMyAnimeListStatusOption interface {
	updateMyAnimeListStatusApply(v *url.Values)
}
func rawOptionFromUpdateMyAnimeListStatusOption(o UpdateMyAnimeListStatusOption) func(v *url.Values) {
	return func(v *url.Values) {
		o.updateMyAnimeListStatusApply(v)
	}
}
var itoa = strconv.Itoa
type Score int
func (s Score) updateMyAnimeListStatusApply(v *url.Values) { v.Set("score", itoa(int(s))) }
func (s Score) updateMyMangaListStatusApply(v *url.Values) { v.Set("score", itoa(int(s))) }
type NumEpisodesWatched int
func (n NumEpisodesWatched) updateMyAnimeListStatusApply(v *url.Values) {
	v.Set("num_watched_episodes", itoa(int(n)))
}
type NumTimesRewatched int
func (n NumTimesRewatched) updateMyAnimeListStatusApply(v *url.Values) {
	v.Set("num_times_rewatched", itoa(int(n)))
}
type IsRewatching bool
func (r IsRewatching) updateMyAnimeListStatusApply(v *url.Values) {
	v.Set("is_rewatching", strconv.FormatBool(bool(r)))
}
type RewatchValue int
func (r RewatchValue) updateMyAnimeListStatusApply(v *url.Values) {
	v.Set("rewatch_value", itoa(int(r)))
}
type Priority int
func (p Priority) updateMyAnimeListStatusApply(v *url.Values) { v.Set("priority", itoa(int(p))) }
func (p Priority) updateMyMangaListStatusApply(v *url.Values) { v.Set("priority", itoa(int(p))) }
type Tags []string
func (t Tags) updateMyAnimeListStatusApply(v *url.Values) { v.Set("tags", strings.Join(t, ",")) }
func (t Tags) updateMyMangaListStatusApply(v *url.Values) { v.Set("tags", strings.Join(t, ",")) }
type Comments string
func (c Comments) updateMyAnimeListStatusApply(v *url.Values) { v.Set("comments", string(c)) }
func (c Comments) updateMyMangaListStatusApply(v *url.Values) { v.Set("comments", string(c)) }
func (s *AnimeService) UpdateMyListStatus(ctx context.Context, animeID int, options ...UpdateMyAnimeListStatusOption) (*AnimeListStatus, *Response, error) {
	u := fmt.Sprintf("anime/%d/my_list_status", animeID)
	rawOptions := make([]func(v *url.Values), len(options))
	for i := range options {
		rawOptions[i] = rawOptionFromUpdateMyAnimeListStatusOption(options[i])
	}
	req, err := s.client.NewRequest(http.MethodPatch, u, rawOptions...)
	if err != nil {
		return nil, nil, err
	}
	a := new(AnimeListStatus)
	resp, err := s.client.Do(ctx, req, a)
	if err != nil {
		return nil, resp, err
	}
	return a, resp, nil
}