func (tmdb *TMDb) SearchTv(name string, options map[string]string) (*TvSearchResults, error) {

        var availableOptions = map[string]struct{}{

                "page":                {},

                "language":            {},

                "search_type":         {},

                "first_air_date_year": {}}

        var shows TvSearchResults

        safeName := url.QueryEscape(name)

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/search/tv?query=%s&api_key=%s%s", baseURL, safeName, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &shows)

        return result.(*TvSearchResults), err

}

func (tmdb *TMDb) SearchKeyword(name string, options map[string]string) (*KeywordSearchResults, error) {

        var availableOptions = map[string]struct{}{

                "page": {}}

        var keywords KeywordSearchResults

        safeName := url.QueryEscape(name)

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/search/keyword?query=%s&api_key=%s%s", baseURL, safeName, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &keywords)

        return result.(*KeywordSearchResults), err

}

func (tmdb *TMDb) SearchCompany(name string, options map[string]string) (*CompanySearchResults, error) {

        var availableOptions = map[string]struct{}{

                "page": {}}

        var companies CompanySearchResults

        safeName := url.QueryEscape(name)

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/search/company?query=%s&api_key=%s%s", baseURL, safeName, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &companies)

        return result.(*CompanySearchResults), err

}

func (tmdb *TMDb) SearchCollection(name string, options map[string]string) (*CollectionSearchResults, error) {

        var availableOptions = map[string]struct{}{

                "page":     {},

                "language": {}}

        var collections CollectionSearchResults

        safeName := url.QueryEscape(name)

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/search/collection?query=%s&api_key=%s%s", baseURL, safeName, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &collections)

        return result.(*CollectionSearchResults), err

}

func (tmdb *TMDb) SearchPerson(name string, options map[string]string) (*PersonSearchResults, error) {

        var availableOptions = map[string]struct{}{

                "page":          {},

                "search_type":   {},

                "include_adult": {}}

        var people PersonSearchResults

        safeName := url.QueryEscape(name)

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/search/person?query=%s&api_key=%s%s", baseURL, safeName, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &people)

        return result.(*PersonSearchResults), err

}

func (tmdb *TMDb) SearchMulti(name string, options map[string]string) (*MultiSearchResults, error) {

        var availableOptions = map[string]struct{}{

                "page":          {},

                "language":      {},

                "include_adult": {}}

        var multis MultiSearchResults

        safeName := url.QueryEscape(name)

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/search/multi?query=%s&api_key=%s%s", baseURL, safeName, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &multis)

        return result.(*MultiSearchResults), err

}

func (tmdb *TMDb) SearchMovie(name string, options map[string]string) (*MovieSearchResults, error) {

        var availableOptions = map[string]struct{}{

                "page":                 {},

                "language":             {},

                "include_adult":        {},

                "year":                 {},

                "primary_release_year": {},

                "search_type":          {}}

        var movies MovieSearchResults

        safeName := url.QueryEscape(name)

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/search/movie?query=%s&api_key=%s%s", baseURL, safeName, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &movies)

        return result.(*MovieSearchResults), err

}

func (tmdb *TMDb) SearchList(name string, options map[string]string) (*ListSearchResults, error) {

        var availableOptions = map[string]struct{}{

                "page":          {},

                "include_adult": {}}

        var lists ListSearchResults

        safeName := url.QueryEscape(name)

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/search/list?query=%s&api_key=%s%s", baseURL, safeName, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &lists)

        return result.(*ListSearchResults), err

}

func (tmdb *TMDb) GetMovieGenres(options map[string]string) (*Genre, error) {

        var availableOptions = map[string]struct{}{

                "language": {}}

        var movieGenres Genre

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/genre/movie/list?api_key=%s%s", baseURL, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &movieGenres)

        return result.(*Genre), err

}

func (tmdb *TMDb) GetCollectionInfo(id int, options map[string]string) (*Collection, error) {

        var availableOptions = map[string]struct{}{

                "language":           {},

                "append_to_response": {}}

        var collection Collection

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/collection/%v?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &collection)

        return result.(*Collection), err

}

func (tmdb *TMDb) GetCollectionImages(id int, options map[string]string) (*CollectionImages, error) {

        var availableOptions = map[string]struct{}{

                "language":               {},

                "append_to_response":     {},

                "include_image_language": {}}

        var images CollectionImages

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/collection/%v/images?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &images)

        return result.(*CollectionImages), err

}

func (tmdb *TMDb) GetCompanyInfo(id int, options map[string]string) (*Company, error) {

        var availableOptions = map[string]struct{}{

                "append_to_response": {}}

        var companyInfo Company

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/company/%v?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &companyInfo)

        return result.(*Company), err

}

func (tmdb *TMDb) GetCompanyMovies(id int, options map[string]string) (*MoviePagedResults, error) {

        var availableOptions = map[string]struct{}{

                "page":               {},

                "language":           {},

                "append_to_response": {}}

        var movies MoviePagedResults

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/company/%v/movies?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &movies)

        return result.(*MoviePagedResults), err

}

func (tmdb *TMDb) GetTvInfo(id int, options map[string]string) (*TV, error) {

        var availableOptions = map[string]struct{}{

                "language":           {},

                "append_to_response": {}}

        var tvInfo TV

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/tv/%v?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &tvInfo)

        return result.(*TV), err

}

func (tmdb *TMDb) GetAccountLists(id int, sessionID string, options map[string]string) (*MovieLists, error) {

        var availableOptions = map[string]struct{}{

                "page":     {},

                "language": {}}

        var lists MovieLists

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/account/%v/lists?api_key=%s&session_id=%s%s", baseURL, id, tmdb.apiKey, sessionID, optionsString)

        result, err := getTmdb(uri, &lists)

        return result.(*MovieLists), err

}

func (tmdb *TMDb) GetAccountFavoriteMovies(id int, sessionID string, options map[string]string) (*MoviePagedResults, error) {

        var availableOptions = map[string]struct{}{

                "page":     {},

                "sort_by":  {},

                "language": {}}

        var favorites MoviePagedResults

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/account/%v/favorite/movies?api_key=%s&session_id=%s%s", baseURL, id, tmdb.apiKey, sessionID, optionsString)

        result, err := getTmdb(uri, &favorites)

        return result.(*MoviePagedResults), err

}

func (tmdb *TMDb) GetAccountFavoriteTv(id int, sessionID string, options map[string]string) (*TvPagedResults, error) {

        var availableOptions = map[string]struct{}{

                "page":     {},

                "sort_by":  {},

                "language": {}}

        var favorites TvPagedResults

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/account/%v/favorite/tv?api_key=%s&session_id=%s%s", baseURL, id, tmdb.apiKey, sessionID, optionsString)

        result, err := getTmdb(uri, &favorites)

        return result.(*TvPagedResults), err

}

func (tmdb *TMDb) GetAccountRatedMovies(id int, sessionID string, options map[string]string) (*MoviePagedResults, error) {

        var availableOptions = map[string]struct{}{

                "page":     {},

                "sort_by":  {},

                "language": {}}

        var favorites MoviePagedResults

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/account/%v/rated/movies?api_key=%s&session_id=%s%s", baseURL, id, tmdb.apiKey, sessionID, optionsString)

        result, err := getTmdb(uri, &favorites)

        return result.(*MoviePagedResults), err

}

func (tmdb *TMDb) GetAccountRatedTv(id int, sessionID string, options map[string]string) (*TvPagedResults, error) {

        var availableOptions = map[string]struct{}{

                "page":     {},

                "sort_by":  {},

                "language": {}}

        var favorites TvPagedResults

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/account/%v/rated/tv?api_key=%s&session_id=%s%s", baseURL, id, tmdb.apiKey, sessionID, optionsString)

        result, err := getTmdb(uri, &favorites)

        return result.(*TvPagedResults), err

}

func (tmdb *TMDb) GetAccountWatchlistMovies(id int, sessionID string, options map[string]string) (*MoviePagedResults, error) {

        var availableOptions = map[string]struct{}{

                "page":     {},

                "sort_by":  {},

                "language": {}}

        var favorites MoviePagedResults

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/account/%v/watchlist/movies?api_key=%s&session_id=%s%s", baseURL, id, tmdb.apiKey, sessionID, optionsString)

        result, err := getTmdb(uri, &favorites)

        return result.(*MoviePagedResults), err

}

func (tmdb *TMDb) GetAccountWatchlistTv(id int, sessionID string, options map[string]string) (*TvPagedResults, error) {

        var availableOptions = map[string]struct{}{

                "page":     {},

                "sort_by":  {},

                "language": {}}

        var favorites TvPagedResults

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/account/%v/watchlist/tv?api_key=%s&session_id=%s%s", baseURL, id, tmdb.apiKey, sessionID, optionsString)

        result, err := getTmdb(uri, &favorites)

        return result.(*TvPagedResults), err

}

func (tmdb *TMDb) GetMovieReleases(id int, options map[string]string) (*MovieReleases, error) {

        var availableOptions = map[string]struct{}{

                "append_to_response": {}}

        var releases MovieReleases

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/movie/%v/releases?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &releases)

        return result.(*MovieReleases), err

}

func (tmdb *TMDb) GetMovieReviews(id int, options map[string]string) (*MovieReviews, error) {

        var availableOptions = map[string]struct{}{

                "page":               {},

                "language":           {},

                "append_to_response": {}}

        var reviews MovieReviews

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/movie/%v/reviews?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &reviews)

        return result.(*MovieReviews), err

}

func (tmdb *TMDb) GetMovieSimilar(id int, options map[string]string) (*MoviePagedResults, error) {

        var availableOptions = map[string]struct{}{

                "page":               {},

                "language":           {},

                "append_to_response": {}}

        var similar MoviePagedResults

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/movie/%v/similar?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &similar)

        return result.(*MoviePagedResults), err

}

func (tmdb *TMDb) GetPersonTaggedImages(id int, options map[string]string) (*PersonTaggedImages, error) {

        var availableOptions = map[string]struct{}{

                "language": {},

                "page":     {}}

        var images PersonTaggedImages

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/person/%v/tagged_images?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &images)

        return result.(*PersonTaggedImages), err

}

func (tmdb *TMDb) GetMovieTranslations(id int, options map[string]string) (*MovieTranslations, error) {

        var availableOptions = map[string]struct{}{

                "append_to_response": {}}

        var translations MovieTranslations

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/movie/%v/translations?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &translations)

        return result.(*MovieTranslations), err

}

func (tmdb *TMDb) GetMovieVideos(id int, options map[string]string) (*MovieVideos, error) {

        var availableOptions = map[string]struct{}{

                "language":           {},

                "append_to_response": {}}

        var videos MovieVideos

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/movie/%v/videos?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &videos)

        return result.(*MovieVideos), err

}

func (tmdb *TMDb) GetMovieUpcoming(options map[string]string) (*MovieDatedResults, error) {

        var availableOptions = map[string]struct{}{

                "page":     {},

                "language": {}}

        var upcoming MovieDatedResults

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/movie/upcoming?api_key=%s%s", baseURL, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &upcoming)

        return result.(*MovieDatedResults), err

}

func (tmdb *TMDb) GetPersonInfo(id int, options map[string]string) (*Person, error) {

        var availableOptions = map[string]struct{}{

                "append_to_response": {}}

        var personInfo Person

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/person/%v?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &personInfo)

        return result.(*Person), err

}

func (tmdb *TMDb) GetPersonChanges(id int, options map[string]string) (*PersonChanges, error) {

        var availableOptions = map[string]struct{}{

                "start_date": {},

                "end_date":   {}}

        var changes PersonChanges

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/person/%v/changes?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &changes)

        return result.(*PersonChanges), err

}

func (tmdb *TMDb) GetPersonCombinedCredits(id int, options map[string]string) (*PersonCombinedCredits, error) {

        var availableOptions = map[string]struct{}{

                "language":           {},

                "append_to_response": {}}

        var credits PersonCombinedCredits

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/person/%v/combined_credits?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &credits)

        return result.(*PersonCombinedCredits), err

}

func (tmdb *TMDb) GetPersonMovieCredits(id int, options map[string]string) (*PersonMovieCredits, error) {

        var availableOptions = map[string]struct{}{

                "language":           {},

                "append_to_response": {}}

        var credits PersonMovieCredits

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/person/%v/movie_credits?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &credits)

        return result.(*PersonMovieCredits), err

}

func (tmdb *TMDb) GetPersonPopular(options map[string]string) (*PersonPopular, error) {

        var availableOptions = map[string]struct{}{

                "page": {}}

        var popular PersonPopular

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/person/popular?api_key=%s%s", baseURL, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &popular)

        return result.(*PersonPopular), err

}

func (tmdb *TMDb) GetPersonTvCredits(id int, options map[string]string) (*PersonTvCredits, error) {

        var availableOptions = map[string]struct{}{

                "language":           {},

                "append_to_response": {}}

        var credits PersonTvCredits

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/person/%v/tv_credits?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &credits)

        return result.(*PersonTvCredits), err

}

func (tmdb *TMDb) GetTvAiringToday(options map[string]string) (*TvPagedResults, error) {

        var availableOptions = map[string]struct{}{

                "page":     {},

                "language": {},

                "timezone": {}}

        var onAir TvPagedResults

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/tv/airing_today?api_key=%s%s", baseURL, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &onAir)

        return result.(*TvPagedResults), err

}

func (tmdb *TMDb) GetTvChanges(id int, options map[string]string) (*TvChanges, error) {

        var availableOptions = map[string]struct{}{

                "start_date": {},

                "end_date":   {}}

        var changes TvChanges

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/tv/%v/changes?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &changes)

        return result.(*TvChanges), err

}

func (tmdb *TMDb) GetTvCredits(id int, options map[string]string) (*TvCredits, error) {

        var availableOptions = map[string]struct{}{

                "language":           {},

                "append_to_response": {}}

        var credits TvCredits

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/tv/%v/credits?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &credits)

        return result.(*TvCredits), err

}

func (tmdb *TMDb) GetTvImages(id int, options map[string]string) (*TvImages, error) {

        var availableOptions = map[string]struct{}{

                "language":               {},

                "include_image_language": {}}

        var images TvImages

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/tv/%v/images?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &images)

        return result.(*TvImages), err

}

func (tmdb *TMDb) GetTvKeywords(id int, options map[string]string) (*TvKeywords, error) {

        var availableOptions = map[string]struct{}{

                "append_to_response": {}}

        var keywords TvKeywords

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/tv/%v/keywords?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &keywords)

        return result.(*TvKeywords), err

}

func (tmdb *TMDb) GetTvOnTheAir(options map[string]string) (*TvPagedResults, error) {

        var availableOptions = map[string]struct{}{

                "page":     {},

                "language": {}}

        var onAir TvPagedResults

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/tv/on_the_air?api_key=%s%s", baseURL, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &onAir)

        return result.(*TvPagedResults), err

}

func (tmdb *TMDb) GetTvPopular(options map[string]string) (*TvPagedResults, error) {

        var availableOptions = map[string]struct{}{

                "page":     {},

                "language": {}}

        var onAir TvPagedResults

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/tv/popular?api_key=%s%s", baseURL, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &onAir)

        return result.(*TvPagedResults), err

}

func (tmdb *TMDb) GetTvSimilar(id int, options map[string]string) (*TvPagedResults, error) {

        var availableOptions = map[string]struct{}{

                "page":               {},

                "language":           {},

                "append_to_response": {}}

        var similar TvPagedResults

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/tv/%v/similar?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &similar)

        return result.(*TvPagedResults), err

}

func (tmdb *TMDb) GetTvTopRated(options map[string]string) (*TvPagedResults, error) {

        var availableOptions = map[string]struct{}{

                "page":     {},

                "language": {}}

        var onAir TvPagedResults

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/tv/top_rated?api_key=%s%s", baseURL, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &onAir)

        return result.(*TvPagedResults), err

}

func (tmdb *TMDb) GetTvSeasonVideos(showID, seasonNum int, options map[string]string) (*TvVideos, error) {

        var availableOptions = map[string]struct{}{

                "language": {}}

        var videos TvVideos

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/tv/%v/season/%v/videos?api_key=%s%s", baseURL, showID, seasonNum, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &videos)

        return result.(*TvVideos), err

}

func (tmdb *TMDb) GetTvVideos(id int, options map[string]string) (*TvVideos, error) {

        var availableOptions = map[string]struct{}{

                "language": {}}

        var videos TvVideos

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/tv/%v/videos?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &videos)

        return result.(*TvVideos), err

}

func (tmdb *TMDb) GetTvEpisodeInfo(showID, seasonNum, episodeNum int, options map[string]string) (*TvEpisode, error) {

        var availableOptions = map[string]struct{}{

                "language":           {},

                "append_to_response": {}}

        var episode TvEpisode

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/tv/%v/season/%v/episode/%v?api_key=%s%s", baseURL, showID, seasonNum, episodeNum, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &episode)

        return result.(*TvEpisode), err

}

func (tmdb *TMDb) GetTvEpisodeChanges(id int, options map[string]string) (*TvChanges, error) {

        var availableOptions = map[string]struct{}{

                "start_date": {},

                "end_date":   {}}

        var changes TvChanges

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/tv/episode/%v/changes?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &changes)

        return result.(*TvChanges), err

}

func (tmdb *TMDb) GetTvEpisodeExternalIds(showID, seasonNum, episodeNum int, options map[string]string) (*TvExternalIds, error) {

        var availableOptions = map[string]struct{}{

                "language": {}}

        var ids TvExternalIds

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/tv/%v/season/%v/episode/%v/external_ids?api_key=%s%s", baseURL, showID, seasonNum, episodeNum, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &ids)

        return result.(*TvExternalIds), err

}

func (tmdb *TMDb) GetTvEpisodeVideos(showID, seasonNum, episodeNum int, options map[string]string) (*TvVideos, error) {

        var availableOptions = map[string]struct{}{

                "language": {}}

        var videos TvVideos

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/tv/%v/season/%v/episode/%v/videos?api_key=%s%s", baseURL, showID, seasonNum, episodeNum, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &videos)

        return result.(*TvVideos), err

}

func (tmdb *TMDb) GetTvSeasonInfo(showID, seasonID int, options map[string]string) (*TvSeason, error) {

        var availableOptions = map[string]struct{}{

                "language":           {},

                "append_to_response": {}}

        var season TvSeason

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/tv/%v/season/%v?api_key=%s%s", baseURL, showID, seasonID, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &season)

        return result.(*TvSeason), err

}

func (tmdb *TMDb) GetTvSeasonChanges(id int, options map[string]string) (*TvChanges, error) {

        var availableOptions = map[string]struct{}{

                "start_date": {},

                "end_date":   {}}

        var changes TvChanges

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/tv/season/%v/changes?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &changes)

        return result.(*TvChanges), err

}

func (tmdb *TMDb) GetTvSeasonExternalIds(showID, seasonNum int, options map[string]string) (*TvExternalIds, error) {

        var availableOptions = map[string]struct{}{

                "language": {}}

        var ids TvExternalIds

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/tv/%v/season/%v/external_ids?api_key=%s%s", baseURL, showID, seasonNum, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &ids)

        return result.(*TvExternalIds), err

}

func (tmdb *TMDb) GetTvSeasonImages(showID, seasonNum int, options map[string]string) (*TvSeasonImages, error) {

        var availableOptions = map[string]struct{}{

                "language":               {},

                "include_image_language": {}}

        var images TvSeasonImages

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/tv/%v/season/%v/images?api_key=%s%s", baseURL, showID, seasonNum, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &images)

        return result.(*TvSeasonImages), err

}

func (tmdb *TMDb) GetCreditInfo(id string, options map[string]string) (*Credit, error) {

        var availableOptions = map[string]struct{}{

                "language": {}}

        var creditInfo Credit

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/credit/%v?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &creditInfo)

        return result.(*Credit), err

}

func (tmdb *TMDb) DiscoverMovie(options map[string]string) (*MoviePagedResults, error) {

        var availableOptions = map[string]struct{}{

                "certification_country":    {},

                "certification":            {},

                "certification.lte":        {},

                "include_adult":            {},

                "include_video":            {},

                "language":                 {},

                "page":                     {},

                "primary_release_year":     {},

                "primary_release_date.gte": {},

                "primary_release_date.lte": {},

                "release_date.gte":         {},

                "release_date.lte":         {},

                "sort_by":                  {},

                "vote_count.gte":           {},

                "vote_count.lte":           {},

                "vote_average.gte":         {},

                "vote_average.lte":         {},

                "with_cast":                {},

                "with_crew":                {},

                "with_companies":           {},

                "with_genres":              {},

                "with_keywords":            {},

                "with_people":              {},

                "year":                     {}}

        optionsString := getOptionsString(options, availableOptions)

        var results MoviePagedResults

        uri := fmt.Sprintf("%s/discover/movie?api_key=%s%s", baseURL, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &results)

        return result.(*MoviePagedResults), err

}

func (tmdb *TMDb) DiscoverTV(options map[string]string) (*TvPagedResults, error) {

        var availableOptions = map[string]struct{}{

                "page":                {},

                "language":            {},

                "sort_by":             {},

                "first_air_date_year": {},

                "first_air_date.gte":  {},

                "first_air_date.lte":  {},

                "vote_count.gte":      {},

                "vote_average.gte":    {},

                "with_genres":         {},

                "with_networks":       {}}

        optionsString := getOptionsString(options, availableOptions)

        var results TvPagedResults

        uri := fmt.Sprintf("%s/discover/tv?api_key=%s%s", baseURL, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &results)

        return result.(*TvPagedResults), err

}

func (tmdb *TMDb) GetFind(id, source string, options map[string]string) (*FindResults, error) {

        var availableOptions = map[string]struct{}{

                "language": {}}

        var results FindResults

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/find/%s?api_key=%s&external_source=%s%s", baseURL, id, tmdb.apiKey, source, optionsString)

        result, err := getTmdb(uri, &results)

        return result.(*FindResults), err

}

func (tmdb *TMDb) GetTvGenres(options map[string]string) (*Genre, error) {

        var availableOptions = map[string]struct{}{

                "language": {}}

        var tvGenres Genre

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/genre/tv/list?api_key=%s%s", baseURL, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &tvGenres)

        return result.(*Genre), err

}

func (tmdb *TMDb) GetGuestSessionRatedMovies(sessionID string, options map[string]string) (*MoviePagedResults, error) {

        var availableOptions = map[string]struct{}{

                "page":       {},

                "sort_by":    {},

                "sort_order": {},

                "language":   {}}

        var favorites MoviePagedResults

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/guest_session/%v/rated_movies?api_key=%s%s", baseURL, sessionID, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &favorites)

        return result.(*MoviePagedResults), err

}

func (tmdb *TMDb) GetKeywordMovies(id int, options map[string]string) (*MoviePagedResults, error) {

        var availableOptions = map[string]struct{}{

                "language": {},

                "page":     {}}

        var movies MoviePagedResults

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/keyword/%v/movies?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &movies)

        return result.(*MoviePagedResults), err

}

func getTmdb(url string, payload interface{}) (interface{}, error) {

        res, err := http.Get(url)

        if err == nil {

                body, err := ioutil.ReadAll(res.Body)

                if err == nil {

                        json.Unmarshal(body, &payload)

                }

        }

        return payload, err

}

func getOptionsString(options map[string]string, availableOptions map[string]struct{}) string {

        var optionsString = ""

        for key, val := range options {

                if _, ok := availableOptions[key]; ok {

                        newString := fmt.Sprintf("%s&%s=%s", optionsString, key, val)

                        optionsString = newString

                }

        }

        return optionsString

}

func (tmdb *TMDb) GetMovieInfo(id int, options map[string]string) (*Movie, error) {

        var availableOptions = map[string]struct{}{

                "language":           {},

                "append_to_response": {}}

        var movie Movie

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/movie/%v?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &movie)

        return result.(*Movie), err

}

func (tmdb *TMDb) GetMovieTopRated(options map[string]string) (*MoviePagedResults, error) {

        var availableOptions = map[string]struct{}{

                "page":     {},

                "language": {}}

        var topRated MoviePagedResults

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/movie/top_rated?api_key=%s%s", baseURL, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &topRated)

        return result.(*MoviePagedResults), err

}

func (tmdb *TMDb) GetMovieAlternativeTitles(id int, options map[string]string) (*MovieAlternativeTitles, error) {

        var availableOptions = map[string]struct{}{

                "country":            {},

                "append_to_response": {}}

        var titles MovieAlternativeTitles

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/movie/%v/alternative_titles?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &titles)

        return result.(*MovieAlternativeTitles), err

}

func (tmdb *TMDb) GetMovieChanges(id int, options map[string]string) (*MovieChanges, error) {

        var availableOptions = map[string]struct{}{

                "start_date": {},

                "end_date":   {}}

        var changes MovieChanges

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/movie/%v/changes?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &changes)

        return result.(*MovieChanges), err

}

func (tmdb *TMDb) GetMovieCredits(id int, options map[string]string) (*MovieCredits, error) {

        var availableOptions = map[string]struct{}{

                "append_to_response": {}}

        var credits MovieCredits

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/movie/%v/credits?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &credits)

        return result.(*MovieCredits), err

}

func (tmdb *TMDb) GetMovieImages(id int, options map[string]string) (*MovieImages, error) {

        var availableOptions = map[string]struct{}{

                "language":               {},

                "append_to_response":     {},

                "include_image_language": {}}

        var images MovieImages

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/movie/%v/images?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &images)

        return result.(*MovieImages), err

}

func (tmdb *TMDb) GetMovieKeywords(id int, options map[string]string) (*MovieKeywords, error) {

        var availableOptions = map[string]struct{}{

                "append_to_response": {}}

        var keywords MovieKeywords

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/movie/%v/keywords?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &keywords)

        return result.(*MovieKeywords), err

}

func (tmdb *TMDb) GetMovieLists(id int, options map[string]string) (*MovieLists, error) {

        var availableOptions = map[string]struct{}{

                "page":               {},

                "language":           {},

                "append_to_response": {}}

        var lists MovieLists

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/movie/%v/lists?api_key=%s%s", baseURL, id, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &lists)

        return result.(*MovieLists), err

}

func (tmdb *TMDb) GetMovieNowPlaying(options map[string]string) (*MovieDatedResults, error) {

        var availableOptions = map[string]struct{}{

                "page":     {},

                "language": {}}

        var nowPlaying MovieDatedResults

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/movie/now_playing?api_key=%s%s", baseURL, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &nowPlaying)

        return result.(*MovieDatedResults), err

}

func (tmdb *TMDb) GetMoviePopular(options map[string]string) (*MoviePagedResults, error) {

        var availableOptions = map[string]struct{}{

                "page":     {},

                "language": {}}

        var popular MoviePagedResults

        optionsString := getOptionsString(options, availableOptions)

        uri := fmt.Sprintf("%s/movie/popular?api_key=%s%s", baseURL, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &popular)

        return result.(*MoviePagedResults), err

}

func (tmdb *TMDb) GetChangesPerson(options map[string]string) (*Changes, error) {

        var personChanges Changes

        optionsString := getOptionsString(options, changeOptions)

        uri := fmt.Sprintf("%s/person/changes?api_key=%s%s", baseURL, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &personChanges)

        return result.(*Changes), err

}

func (tmdb *TMDb) GetChangesTv(options map[string]string) (*Changes, error) {

        var tvChanges Changes

        optionsString := getOptionsString(options, changeOptions)

        uri := fmt.Sprintf("%s/tv/changes?api_key=%s%s", baseURL, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &tvChanges)

        return result.(*Changes), err

}

func (tmdb *TMDb) GetChangesMovie(options map[string]string) (*Changes, error) {

        var movieChanges Changes

        optionsString := getOptionsString(options, changeOptions)

        uri := fmt.Sprintf("%s/movie/changes?api_key=%s%s", baseURL, tmdb.apiKey, optionsString)

        result, err := getTmdb(uri, &movieChanges)

        return result.(*Changes), err

}

func (tmdb *TMDb) GetTvAccountStates(id int, sessionID string) (*TvAccountState, error) {

        var state TvAccountState

        uri := fmt.Sprintf("%s/tv/%v/account_states?api_key=%s&session_id=%s", baseURL, id, tmdb.apiKey, sessionID)

        result, err := getTmdb(uri, &state)

        return result.(*TvAccountState), err

}

func (tmdb *TMDb) GetNetworkInfo(id int) (*Network, error) {

        var networkInfo Network

        uri := fmt.Sprintf("%s/network/%v?api_key=%s", baseURL, id, tmdb.apiKey)

        result, err := getTmdb(uri, &networkInfo)

        return result.(*Network), err

}

func (tmdb *TMDb) GetAccountInfo(sessionID string) (*AccountInfo, error) {

        var account AccountInfo

        uri := fmt.Sprintf("%s/account?api_key=%s&session_id=%s", baseURL, tmdb.apiKey, sessionID)

        result, err := getTmdb(uri, &account)

        return result.(*AccountInfo), err

}

func (tmdb *TMDb) GetTvLatest() (*TV, error) {

        var tv TV

        uri := fmt.Sprintf("%s/tv/latest?api_key=%s", baseURL, tmdb.apiKey)

        result, err := getTmdb(uri, &tv)

        return result.(*TV), err

}

func (tmdb *TMDb) GetTvAlternativeTitles(id int) (*TvAlternativeTitles, error) {

        var titles TvAlternativeTitles

        uri := fmt.Sprintf("%s/tv/%v/alternative_titles?api_key=%s", baseURL, id, tmdb.apiKey)

        result, err := getTmdb(uri, &titles)

        return result.(*TvAlternativeTitles), err

}

func (tmdb *TMDb) GetJobList() (*Job, error) {

        var jobList Job

        uri := fmt.Sprintf("%s/job/list?api_key=%s", baseURL, tmdb.apiKey)

        result, err := getTmdb(uri, &jobList)

        return result.(*Job), err

}

func (tmdb *TMDb) GetKeywordInfo(id int) (*Keyword, error) {

        var keywordInfo Keyword

        uri := fmt.Sprintf("%s/keyword/%v?api_key=%s", baseURL, id, tmdb.apiKey)

        result, err := getTmdb(uri, &keywordInfo)

        return result.(*Keyword), err

}

func (tmdb *TMDb) GetTvEpisodeCredits(showID, seasonNum, episodeNum int) (*TvCredits, error) {

        var credits TvCredits

        uri := fmt.Sprintf("%s/tv/%v/season/%v/episode/%v/credits?api_key=%s", baseURL, showID, seasonNum, episodeNum, tmdb.apiKey)

        result, err := getTmdb(uri, &credits)

        return result.(*TvCredits), err

}

func (tmdb *TMDb) GetListInfo(id string) (*ListInfo, error) {

        var listInfo ListInfo

        uri := fmt.Sprintf("%s/list/%v?api_key=%s", baseURL, id, tmdb.apiKey)

        result, err := getTmdb(uri, &listInfo)

        return result.(*ListInfo), err

}

func (tmdb *TMDb) GetListItemStatus(id string, movieID int) (*ListItemStatus, error) {

        var itemStatus ListItemStatus

        uri := fmt.Sprintf("%s/list/%v/item_status?api_key=%s&movie_id=%v", baseURL, id, tmdb.apiKey, movieID)

        result, err := getTmdb(uri, &itemStatus)

        return result.(*ListItemStatus), err

}

func (tmdb *TMDb) GetPersonExternalIds(id int) (*TvExternalIds, error) {

        var ids TvExternalIds

        uri := fmt.Sprintf("%s/person/%v/external_ids?api_key=%s", baseURL, id, tmdb.apiKey)

        result, err := getTmdb(uri, &ids)

        return result.(*TvExternalIds), err

}

func (tmdb *TMDb) GetPersonImages(id int) (*PersonImages, error) {

        var images PersonImages

        uri := fmt.Sprintf("%s/person/%v/images?api_key=%s", baseURL, id, tmdb.apiKey)

        result, err := getTmdb(uri, &images)

        return result.(*PersonImages), err

}

func (tmdb *TMDb) GetPersonLatest() (*PersonLatest, error) {

        var latest PersonLatest

        uri := fmt.Sprintf("%s/person/latest?api_key=%s", baseURL, tmdb.apiKey)

        result, err := getTmdb(uri, &latest)

        return result.(*PersonLatest), err

}

func (tmdb *TMDb) GetTvSeasonCredits(showID, seasonNum int) (*TvCredits, error) {

        var credits TvCredits

        uri := fmt.Sprintf("%s/tv/%v/season/%v/credits?api_key=%s", baseURL, showID, seasonNum, tmdb.apiKey)

        result, err := getTmdb(uri, &credits)

        return result.(*TvCredits), err

}

func (tmdb *TMDb) GetTvEpisodeImages(showID, seasonNum, episodeNum int) (*TvEpisodeImages, error) {

        var images TvEpisodeImages

        uri := fmt.Sprintf("%s/tv/%v/season/%v/episode/%v/images?api_key=%s", baseURL, showID, seasonNum, episodeNum, tmdb.apiKey)

        result, err := getTmdb(uri, &images)

        return result.(*TvEpisodeImages), err

}

func (tmdb *TMDb) GetMovieAccountStates(id int, sessionID string) (*MovieAccountState, error) {

        var state MovieAccountState

        uri := fmt.Sprintf("%s/movie/%v/account_states?api_key=%s&session_id=%s", baseURL, id, tmdb.apiKey, sessionID)

        result, err := getTmdb(uri, &state)

        return result.(*MovieAccountState), err

}

func (tmdb *TMDb) GetCertificationsTvList() (*Certification, error) {

        var tvCert Certification

        uri := fmt.Sprintf("%s/certification/tv/list?api_key=%s", baseURL, tmdb.apiKey)

        result, err := getTmdb(uri, &tvCert)

        return result.(*Certification), err

}

func (tmdb *TMDb) GetReviewInfo(id string) (*Review, error) {

        var reviewInfo Review

        uri := fmt.Sprintf("%s/review/%v?api_key=%s", baseURL, id, tmdb.apiKey)

        result, err := getTmdb(uri, &reviewInfo)

        return result.(*Review), err

}

func (tmdb *TMDb) GetMovieLatest() (*Movie, error) {

        var movie Movie

        uri := fmt.Sprintf("%s/movie/latest?api_key=%s", baseURL, tmdb.apiKey)

        result, err := getTmdb(uri, &movie)

        return result.(*Movie), err

}

func (tmdb *TMDb) GetConfiguration() (*Configuration, error) {

        var config Configuration

        uri := fmt.Sprintf("%s/configuration?api_key=%s", baseURL, tmdb.apiKey)

        result, err := getTmdb(uri, &config)

        return result.(*Configuration), err

}

func (tmdb *TMDb) GetTimezonesList() (*Timezones, error) {

        var timezoneList Timezones

        uri := fmt.Sprintf("%s/timezones/list?api_key=%s", baseURL, tmdb.apiKey)

        result, err := getTmdb(uri, &timezoneList)

        return result.(*Timezones), err

}

func (tmdb *TMDb) GetTvTranslations(id int) (*TvTranslations, error) {

        var translations TvTranslations

        uri := fmt.Sprintf("%s/tv/%v/translations?api_key=%s", baseURL, id, tmdb.apiKey)

        result, err := getTmdb(uri, &translations)

        return result.(*TvTranslations), err

}

func (tmdb *TMDb) GetAuthValidateToken(token, user, password string) (*AuthenticationToken, error) {

        var validToken AuthenticationToken

        uri := fmt.Sprintf("%s/authentication/token/validate_with_login?api_key=%s&request_token=%s&username=%s&password=%s", baseURL, tmdb.apiKey, token, user, password)

        result, err := getTmdb(uri, &validToken)

        return result.(*AuthenticationToken), err

}

func (tmdb *TMDb) GetAuthToken() (*AuthenticationToken, error) {

        var token AuthenticationToken

        uri := fmt.Sprintf("%s/authentication/token/new?api_key=%s", baseURL, tmdb.apiKey)

        result, err := getTmdb(uri, &token)

        return result.(*AuthenticationToken), err

}

func (tmdb *TMDb) GetCertificationsMovieList() (*Certification, error) {

        var movieCert Certification

        uri := fmt.Sprintf("%s/certification/movie/list?api_key=%s", baseURL, tmdb.apiKey)

        result, err := getTmdb(uri, &movieCert)

        return result.(*Certification), err

}

func (tmdb *TMDb) GetAuthGuestSession() (*AuthenticationGuestSession, error) {

        var session AuthenticationGuestSession

        uri := fmt.Sprintf("%s/authentication/guest_session/new?api_key=%s", baseURL, tmdb.apiKey)

        result, err := getTmdb(uri, &session)

        return result.(*AuthenticationGuestSession), err

}

func (tmdb *TMDb) GetAuthSession(token string) (*AuthenticationSession, error) {

        var session AuthenticationSession

        uri := fmt.Sprintf("%s/authentication/session/new?api_key=%s&request_token=%s", baseURL, tmdb.apiKey, token)

        result, err := getTmdb(uri, &session)

        return result.(*AuthenticationSession), err

}

func ToJSON(payload interface{}) (string, error) {

        jsonRes := []byte("{}") //Default value in case of error

        jsonRes, err := json.MarshalIndent(payload, "", "  ")

        return string(jsonRes), err

}

func Init(apiKey string) *TMDb {

        return &TMDb{apiKey: apiKey}

}