add error. linting

Update package.json

.eslintrc.js

@@ -2,42 +2,21 @@ module.exports = {
   env: {
     browser: false,
     es2021: true,
+    node: true,
   },
   extends: [
-    'plugin:@typescript-eslint/recommended',
+    "eslint:recommended",
+    "plugin:@typescript-eslint/eslint-recommended",
+    "plugin:@typescript-eslint/recommended",
+    "prettier",
   ],
-  parser: '@typescript-eslint/parser',
+  parser: "@typescript-eslint/parser",
   parserOptions: {
     ecmaVersion: 12,
-    sourceType: 'module',
+    sourceType: "module",
   },
-  plugins: [
+  rules:{
-    '@typescript-eslint',
+    'linebreak-style': ['off', 'unix'],
-  ],
-  rules: {
-    '@typescript-eslint/no-var-requires': 'off',
-    '@typescript-eslint/no-explicit-any': 'off',
-    '@typescript-eslint/interface-name-prefix': 'off',
-    '@typescript-eslint/no-non-null-assertion': 'off',
-    '@typescript-eslint/no-use-before-define': 'off',
-    '@typescript-eslint/no-empty-interface': 'off',
-    '@typescript-eslint/explicit-function-return-type': ['warn', { allowExpressions: true }],
-    indent: 'off',
-    '@typescript-eslint/indent': ['error', 2],
-    'no-trailing-spaces': 'error',
-    quotes: ['error', 'single', { allowTemplateLiterals: true }],
-    semi: ['error', 'always'],
-    'spaced-comment': ['error', 'always'],
-    'no-irregular-whitespace': ['error', { 'skipComments': true }],
-    'space-infix-ops': 'error',
-    'array-bracket-spacing': 'error',
-    'object-curly-spacing': ['error', 'always'],
-    'space-before-function-paren': ['error', {
-      named: 'never',
-      anonymous: 'never',
-      asyncArrow: 'always',
-    }],
-    'comma-dangle': ['warn', 'always-multiline'],
-    'no-multiple-empty-lines': 'error',
   },
+  plugins: ["@typescript-eslint"],
 };

.github/workflows/npm-publish.yml

@@ -0,0 +1,33 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - run: npm ci
+      - run: npm test
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+          registry-url: https://registry.npmjs.org/
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npm run lint

.nvmrc

@@ -0,0 +1 @@
+v18.16.0

.prettierignore

@@ -0,0 +1,3 @@
+dist
+node_modules
+.github

.prettierrc

@@ -0,0 +1,12 @@
+{
+  "printWidth": 80,
+  "tabWidth": 2,
+  "useTabs": false,
+  "semi": true,
+  "singleQuote": true,
+  "trailingComma": "es5",
+  "bracketSpacing": true,
+  "arrowParens": "always",
+  "proseWrap": "never",
+  "htmlWhitespaceSensitivity": "strict"
+}

README.md

@@ -14,8 +14,10 @@ Installation:
 npm install --save tmdb-ts
 ``
 
+Version 1.0 removed the default import so make sure you update accordingly!
+
 ```js
-import TMDB from 'tmdb-ts';
+import { TMDB } from 'tmdb-ts';
 
 const tmdb = new TMDB('accessToken');
 

package.json

@@ -1,15 +1,15 @@
 {
   "name": "tmdb-ts",
-  "version": "0.1.8",
+  "version": "1.6.1",
   "description": "TMDB v3 library wrapper",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "compile": "rm -rf dist && tsc -d && npm run copy-types",
+    "compile": "rm -rf dist && tsc -d",
     "lint": "eslint --ext .ts src/",
     "lint:fix": "eslint --ext .ts src/ --fix",
-    "prepublish": "tsc",
+    "format": "npx prettier --write src",
-    "copy-types": "mkdir dist/types && cp src/types/*.d.ts dist/types"
+    "pre-commit": "npm run lint"
   },
   "bugs": {
     "url": "https://github.com/blakejoy/tmdb-ts/issues",
@@ -29,24 +29,32 @@
   "author": "Blake Joynes",
   "license": "MIT",
   "devDependencies": {
-    "@types/node": "^15.3.0",
+    "@types/node": "^18.15.11",
     "@types/node-fetch": "^2.5.10",
-    "@typescript-eslint/eslint-plugin": "^4.23.0",
+    "@typescript-eslint/eslint-plugin": "^5.58.0",
-    "@typescript-eslint/parser": "^4.23.0",
+    "@typescript-eslint/parser": "^5.58.0",
     "dotenv": "^9.0.2",
-    "eslint": "^7.26.0",
+    "eslint": "^8.38.0",
-    "eslint-config-airbnb-base": "^14.2.1",
+    "eslint-config-airbnb-typescript": "^17.0.0",
-    "eslint-plugin-import": "^2.23.1",
+    "eslint-config-prettier": "^8.8.0",
-    "ts-node": "^9.1.1",
+    "eslint-plugin-prettier": "^4.2.1",
-    "typescript": "^4.2.4"
+    "husky": "^8.0.3",
+    "prettier": "^2.8.7",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.9.5"
   },
   "dependencies": {
     "cross-fetch": "^3.1.4"
   },
   "volta": {
-    "node": "15.13.0",
+    "node": "18.16.0",
-    "yarn": "1.19.2",
+    "yarn": "1.22.4",
-    "npm": "7.12.1"
+    "npm": "9.5.1"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "npm run pre-commit"
+    }
   },
   "files": [
     "dist"

src/api.ts

@@ -1,20 +1,28 @@
 import fetch from 'cross-fetch';
+import { parseOptions } from './utils';
+import { ErrorResponse } from './types';
 
 const BASE_URL_V3 = 'https://api.themoviedb.org/3';
 
-export default class Api {
+export class Api {
   constructor(private accessToken: string) {
     this.accessToken = accessToken;
   }
 
-  async get<T>(path: string): Promise<T> {
+  async get<T>(path: string, options?: Record<string, any>): Promise<T> {
-    const response = await fetch(`${BASE_URL_V3}${path}`, {
+    const params = parseOptions(options);
+    const response = await fetch(`${BASE_URL_V3}${path}?${params}`, {
       method: 'GET',
       headers: {
         Authorization: `Bearer ${this.accessToken}`,
         'Content-Type': 'application/json;charset=utf-8',
       },
     });
-    return await response.json() as T;
+
+    if (!response.ok) {
+      return Promise.reject((await response.json()) as ErrorResponse);
+    }
+
+    return (await response.json()) as T;
   }
 }

src/endpoints/account.ts

@@ -1,11 +1,12 @@
 import { BaseEndpoint } from './base';
+import { AccountDetails } from '../types/account';
 
 export class AccountEndpoint extends BaseEndpoint {
   constructor(accessToken: string) {
     super(accessToken);
   }
 
-  async details(): Promise<any> {
+  async details(): Promise<AccountDetails> {
     return await this.api.get('/account');
   }
 }

src/endpoints/base.ts

@@ -1,4 +1,4 @@
-import Api from '../api';
+import { Api } from '../api';
 
 export class BaseEndpoint {
   protected api: Api;

src/endpoints/certification.ts

@@ -1,4 +1,4 @@
-import {  BaseEndpoint } from './base';
+import { BaseEndpoint } from './base';
 import { Certifications } from '../types/certification';
 
 export class CertificationEndpoint extends BaseEndpoint {

src/endpoints/changes.ts

@@ -1,25 +1,20 @@
+import { ChangeOption, MediaChanges } from '../types';
 import { BaseEndpoint } from './base';
-import { ChangeOptions, Changes } from '../types/changes';
-import { parseOptions } from '../utils';
-
 
 export class ChangeEndpoint extends BaseEndpoint {
   constructor(protected readonly accessToken: string) {
     super(accessToken);
   }
 
-  async movies(options?: ChangeOptions): Promise<Changes> {
+  async movies(options?: ChangeOption): Promise<MediaChanges> {
-    const params = parseOptions(options);
+    return await this.api.get<MediaChanges>(`/movie/changes`, options);
-    return await this.api.get<Changes>(`/movie/changes?${params}`);
   }
 
-  async tvShows(options?: ChangeOptions): Promise<Changes> {
+  async tvShows(options?: ChangeOption): Promise<MediaChanges> {
-    const params = parseOptions(options);
+    return await this.api.get<MediaChanges>(`/tv/changes`, options);
-    return await this.api.get<Changes>(`/tv/changes?${params}`);
   }
 
-  async person(options?: ChangeOptions): Promise<Changes> {
+  async person(options?: ChangeOption): Promise<MediaChanges> {
-    const params = parseOptions(options);
+    return await this.api.get<MediaChanges>(`/person/change`, options);
-    return await this.api.get<Changes>(`/person/changes${params}`);
   }
 }

src/endpoints/collections.ts

@@ -1,6 +1,11 @@
-import { DetailedCollection, ImageCollection, LanguageOption, Translations } from '../types';
+import {
-import { parseOptions } from '../utils';
+  CollectionImageOptions,
-import {  BaseEndpoint } from './base';
+  DetailedCollection,
+  ImageCollection,
+  LanguageOption,
+  Translations,
+} from '../types';
+import { BaseEndpoint } from './base';
 
 const BASE_COLLECTION = '/collection';
 
@@ -9,18 +14,37 @@ export class CollectionsEndpoint extends BaseEndpoint {
     super(accessToken);
   }
 
-  async details(id: number, options? : LanguageOption): Promise<DetailedCollection> {
+  async details(
-    const params = parseOptions(options);
+    id: number,
-    return await this.api.get<DetailedCollection>(`${BASE_COLLECTION}/${id}?${params}`);
+    options?: LanguageOption
+  ): Promise<DetailedCollection> {
+    return await this.api.get<DetailedCollection>(
+      `${BASE_COLLECTION}/${id}`,
+      options
+    );
   }
 
-  async images(id: number, options? : LanguageOption): Promise<ImageCollection> {
+  async images(
-    const params = parseOptions(options);
+    id: number,
-    return await this.api.get<ImageCollection>(`${BASE_COLLECTION}/${id}/images?${params}`);
+    options?: CollectionImageOptions
+  ): Promise<ImageCollection> {
+    const computedOptions = {
+      include_image_language: options?.include_image_language?.join(','),
+      language: options?.language,
+    };
+    return await this.api.get<ImageCollection>(
+      `${BASE_COLLECTION}/${id}/images`,
+      computedOptions
+    );
   }
 
-  async translations(id: number, options? : LanguageOption): Promise<Translations> {
+  async translations(
-    const params = parseOptions(options);
+    id: number,
-    return await this.api.get<Translations>(`${BASE_COLLECTION}/${id}/translations?${params}`);
+    options?: LanguageOption
+  ): Promise<Translations> {
+    return await this.api.get<Translations>(
+      `${BASE_COLLECTION}/${id}/translations`,
+      options
+    );
   }
-}
+}

src/endpoints/companies.ts

@@ -0,0 +1,26 @@
+import {
+  CompanyDetails,
+  AlternativeNames,
+  CompanyImages,
+} from './../types/companies';
+import { BaseEndpoint } from './base';
+
+export class CompaniesEndpoint extends BaseEndpoint {
+  constructor(protected readonly accessToken: string) {
+    super(accessToken);
+  }
+
+  async details(id: number): Promise<CompanyDetails> {
+    return await this.api.get<CompanyDetails>(`/company/${id}`);
+  }
+
+  async alternativeNames(id: number): Promise<AlternativeNames> {
+    return await this.api.get<AlternativeNames>(
+      `/company/${id}/alternative_names`
+    );
+  }
+
+  async images(id: number): Promise<CompanyImages> {
+    return await this.api.get<CompanyImages>(`/company/${id}/images`);
+  }
+}

src/endpoints/configuration.ts

@@ -9,5 +9,4 @@ export class ConfigurationEndpoint extends BaseEndpoint {
   async getCurrent(): Promise<Configuration> {
     return await this.api.get<Configuration>(`/configuration`);
   }
-
 }

src/endpoints/credits.ts

@@ -1,7 +1,6 @@
 import { BaseEndpoint } from './base';
 import { CreditResponse } from '../types/credits';
 
-
 export class CreditsEndpoint extends BaseEndpoint {
   constructor(protected readonly accessToken: string) {
     super(accessToken);
@@ -10,5 +9,4 @@ export class CreditsEndpoint extends BaseEndpoint {
   async getById(id: string): Promise<CreditResponse> {
     return await this.api.get<CreditResponse>(`/credit/${id}`);
   }
-
 }

src/endpoints/discover.ts

@@ -1,5 +1,8 @@
-import { MovieDiscoverResult, SortOption, TvShowDiscoverResult } from '../types';
+import {
-import { parseOptions } from '../utils';
+  MovieDiscoverResult,
+  SortOption,
+  TvShowDiscoverResult,
+} from '../types';
 import { BaseEndpoint } from './base';
 
 const BASE_DISCOVER = '/discover';
@@ -26,7 +29,7 @@ interface DiscoverQueryOptions {
   with_companies?: string;
 }
 
-interface MovieQueryOptions extends DiscoverQueryOptions{
+interface MovieQueryOptions extends DiscoverQueryOptions {
   region?: string;
   certification_country?: string;
   certification?: string;
@@ -46,7 +49,7 @@ interface MovieQueryOptions extends DiscoverQueryOptions{
   with_people?: string;
 }
 
-interface TvShowQueryOptions extends DiscoverQueryOptions{
+interface TvShowQueryOptions extends DiscoverQueryOptions {
   'air_date.gte'?: string;
   'air_date.lte'?: string;
   'first_air_date.gte'?: string;
@@ -66,12 +69,16 @@ export class DiscoverEndpoint extends BaseEndpoint {
   }
 
   async movie(options?: MovieQueryOptions): Promise<MovieDiscoverResult> {
-    const params = parseOptions(options);
+    return await this.api.get<MovieDiscoverResult>(
-    return await this.api.get<MovieDiscoverResult>(`${BASE_DISCOVER}/movie?${params}`);
+      `${BASE_DISCOVER}/movie`,
+      options
+    );
   }
 
   async tvShow(options?: TvShowQueryOptions): Promise<TvShowDiscoverResult> {
-    const params = parseOptions(options);
+    return await this.api.get<TvShowDiscoverResult>(
-    return await this.api.get<TvShowDiscoverResult>(`${BASE_DISCOVER}/tv?${params}`);
+      `${BASE_DISCOVER}/tv`,
+      options
+    );
   }
 }

src/endpoints/find.ts

@@ -1,14 +1,15 @@
 import { BaseEndpoint } from './base';
 import { ExternalIdOptions, FindResult } from '../types';
-import { parseOptions } from '../utils';
 
 export class FindEndpoint extends BaseEndpoint {
   constructor(accessToken: string) {
     super(accessToken);
   }
 
-  async byId(externalId: string, options: ExternalIdOptions): Promise<FindResult> {
+  async byId(
-    const params = parseOptions(options);
+    externalId: string,
-    return await this.api.get<FindResult>(`/find/${externalId}?${params}`);
+    options: ExternalIdOptions
+  ): Promise<FindResult> {
+    return await this.api.get<FindResult>(`/find/${externalId}`, options);
   }
 }

src/endpoints/genre.ts

@@ -1,7 +1,8 @@
-import {  BaseEndpoint } from './base';
+import { LanguageOption } from '../types';
+import { BaseEndpoint } from './base';
 
 export interface Genres {
-  genres: Array<{id: number, name: string}>
+  genres: Array<{ id: number; name: string }>;
 }
 
 export class GenreEndpoint extends BaseEndpoint {
@@ -9,11 +10,11 @@ export class GenreEndpoint extends BaseEndpoint {
     super(accessToken);
   }
 
-  async movies(): Promise<Genres> {
+  async movies(options?: LanguageOption): Promise<Genres> {
-    return await this.api.get<Genres>('/genre/movie/list');
+    return await this.api.get<Genres>('/genre/movie/list', options);
   }
 
-  async tvShows(): Promise<Genres> {
+  async tvShows(options?: LanguageOption): Promise<Genres> {
-    return await this.api.get<Genres>('/genre/tv/list');
+    return await this.api.get<Genres>('/genre/tv/list', options);
   }
 }

src/endpoints/index.ts

@@ -1,5 +1,3 @@
-
-
 export * from './account';
 export * from './certification';
 export * from './changes';
@@ -16,4 +14,5 @@ export * from './trending';
 export * from './find';
 export * from './keywords';
 export * from './collections';
-
+export * from './tv-seasons';
+export * from './tv-episode';

src/endpoints/keywords.ts

@@ -1,6 +1,5 @@
 import { BaseEndpoint } from './base';
 import { BelongingMovies, Keyword, KeywordsOptions } from '../types';
-import { parseOptions } from '../utils';
 
 const BASE_Keyword = '/keyword';
 
@@ -9,12 +8,17 @@ export class KeywordsEndpoint extends BaseEndpoint {
     super(accessToken);
   }
 
-  async details(keywordId : number): Promise<Keyword> {
+  async details(keywordId: number): Promise<Keyword> {
     return await this.api.get<Keyword>(`${BASE_Keyword}/${keywordId}`);
   }
 
-  async belongingMovies(keywordId : number, options?: KeywordsOptions): Promise<BelongingMovies> {
+  async belongingMovies(
-    const params = parseOptions(options);
+    keywordId: number,
-    return await this.api.get<BelongingMovies>(`${BASE_Keyword}/${keywordId}/movies?${params}`);
+    options?: KeywordsOptions
+  ): Promise<BelongingMovies> {
+    return await this.api.get<BelongingMovies>(
+      `${BASE_Keyword}/${keywordId}/movies`,
+      options
+    );
   }
 }

src/endpoints/movies.ts

@@ -1,14 +1,17 @@
 import { BaseEndpoint } from './base';
 import {
   AlternativeTitles,
-  ChangeOptions,
+  AppendToResponse,
+  AppendToResponseMovieKey,
+  ChangeOption,
+  Changes,
   Credits,
   ExternalIds,
   Images,
   Keywords,
   LanguageOption,
   LatestMovie,
-  MovieChanges,
+  MovieChangeValue,
   MovieDetails,
   MovieLists,
   MoviesPlayingNow,
@@ -19,112 +22,177 @@ import {
   ReleaseDates,
   Reviews,
   SimilarMovies,
-  TopRatedMovies, Translations,
+  TopRatedMovies,
+  Translations,
   UpcomingMovies,
   Videos,
   WatchProviders,
 } from '../types';
-import { parseOptions } from '../utils';
 
 const BASE_MOVIE = '/movie';
 
-export class MoviesEndpoint extends BaseEndpoint{
+export interface MoviesImageSearchOptions extends LanguageOption {
+  /**
+   * a list of ISO-639-1 values to query
+   */
+  include_image_language?: string[];
+}
+
+export class MoviesEndpoint extends BaseEndpoint {
   constructor(protected readonly accessToken: string) {
     super(accessToken);
   }
 
-  async details(id: number): Promise<MovieDetails>{
+  async details<T extends AppendToResponseMovieKey[] | undefined>(
-    return await this.api.get<MovieDetails>(`${BASE_MOVIE}/${id}`);
+    id: number,
+    appendToResponse?: T,
+    language?: string
+  ) {
+    const options = {
+      append_to_response: appendToResponse
+        ? appendToResponse.join(',')
+        : undefined,
+      language: language,
+    };
+
+    return await this.api.get<AppendToResponse<MovieDetails, T, 'movie'>>(
+      `${BASE_MOVIE}/${id}`,
+      options
+    );
   }
 
-  async alternativeTitles(id: number): Promise<AlternativeTitles>{
+  async alternativeTitles(id: number): Promise<AlternativeTitles> {
-    return await this.api.get<AlternativeTitles>(`${BASE_MOVIE}/${id}/alternative_titles`);
+    return await this.api.get<AlternativeTitles>(
+      `${BASE_MOVIE}/${id}/alternative_titles`
+    );
   }
 
-  async changes(id: number, options?: ChangeOptions): Promise<MovieChanges>{
+  async changes(
-    const params = parseOptions(options);
+    id: number,
-    return await this.api.get<MovieChanges>(`${BASE_MOVIE}/${id}/changes?${params}`);
+    options?: ChangeOption
+  ): Promise<Changes<MovieChangeValue>> {
+    return await this.api.get<Changes<MovieChangeValue>>(
+      `${BASE_MOVIE}/${id}/changes`,
+      options
+    );
   }
 
-  async credits(id: number): Promise<Credits>{
+  async credits(id: number, options?: LanguageOption): Promise<Credits> {
-    return await this.api.get<Credits>(`${BASE_MOVIE}/${id}/credits`);
+    return await this.api.get<Credits>(`${BASE_MOVIE}/${id}/credits`, options);
   }
 
-  async externalIds(id: number): Promise<ExternalIds>{
+  async externalIds(id: number): Promise<ExternalIds> {
     return await this.api.get<ExternalIds>(`${BASE_MOVIE}/${id}/external_ids`);
   }
 
-  async images(id: number): Promise<Images>{
+  async images(
-    return await this.api.get<Images>(`${BASE_MOVIE}/${id}/images`);
+    id: number,
+    options?: MoviesImageSearchOptions
+  ): Promise<Images> {
+    const computedOptions = {
+      include_image_language: options?.include_image_language?.join(','),
+      language: options?.language,
+    };
+    return await this.api.get<Images>(
+      `${BASE_MOVIE}/${id}/images`,
+      computedOptions
+    );
   }
 
-  async keywords(id: number): Promise<Keywords>{
+  async keywords(id: number): Promise<Keywords> {
     return await this.api.get<Keywords>(`${BASE_MOVIE}/${id}/keywords`);
   }
 
-  async lists(id: number, options?: LanguageOption | PageOption): Promise<MovieLists>{
+  async lists(
-    const params = parseOptions(options);
+    id: number,
-    return await this.api.get<MovieLists>(`${BASE_MOVIE}/${id}/lists?${params}`);
+    options?: LanguageOption & PageOption
+  ): Promise<MovieLists> {
+    return await this.api.get<MovieLists>(`${BASE_MOVIE}/${id}/lists`, options);
   }
 
-  async recommendations(id: number, options?: PageOption): Promise<Recommendations>{
+  async recommendations(
-    const params = parseOptions(options);
+    id: number,
-    return await this.api.get<Recommendations>(`${BASE_MOVIE}/${id}/recommendations?${params}`);
+    options?: LanguageOption & PageOption
+  ): Promise<Recommendations> {
+    return await this.api.get<Recommendations>(
+      `${BASE_MOVIE}/${id}/recommendations`,
+      options
+    );
   }
 
-  async releaseDates(id: number): Promise<ReleaseDates>{
+  async releaseDates(id: number): Promise<ReleaseDates> {
-    return await this.api.get<ReleaseDates>(`${BASE_MOVIE}/${id}/release_dates`);
+    return await this.api.get<ReleaseDates>(
+      `${BASE_MOVIE}/${id}/release_dates`
+    );
   }
 
-  async reviews(id: number, options?: PageOption): Promise<Reviews>{
+  async reviews(
-    const params = parseOptions(options);
+    id: number,
-    return await this.api.get<Reviews>(`${BASE_MOVIE}/${id}/reviews?${params}`);
+    options?: LanguageOption & PageOption
+  ): Promise<Reviews> {
+    return await this.api.get<Reviews>(`${BASE_MOVIE}/${id}/reviews`, options);
   }
 
-  async similar(id: number, options?: PageOption): Promise<SimilarMovies>{
+  async similar(
-    const params = parseOptions(options);
+    id: number,
-    return await this.api.get<SimilarMovies>(`${BASE_MOVIE}/${id}/similar?${params}`);
+    options?: LanguageOption & PageOption
+  ): Promise<SimilarMovies> {
+    return await this.api.get<SimilarMovies>(
+      `${BASE_MOVIE}/${id}/similar`,
+      options
+    );
   }
 
-  async translations(id: number): Promise<Translations>{
+  async translations(id: number): Promise<Translations> {
     return await this.api.get<Translations>(`${BASE_MOVIE}/${id}/translations`);
   }
 
-  async videos(id: number): Promise<Videos>{
+  async videos(id: number, options?: LanguageOption): Promise<Videos> {
-    return await this.api.get<Videos>(`${BASE_MOVIE}/${id}/videos`);
+    return await this.api.get<Videos>(`${BASE_MOVIE}/${id}/videos`, options);
   }
 
   /**
    * Powered by JustWatch
    * @param id
    */
-  async watchProviders(id: number): Promise<WatchProviders>{
+  async watchProviders(id: number): Promise<WatchProviders> {
-    return await this.api.get<WatchProviders>(`${BASE_MOVIE}/${id}/watch/providers`);
+    return await this.api.get<WatchProviders>(
+      `${BASE_MOVIE}/${id}/watch/providers`
+    );
   }
 
-  async latest(): Promise<LatestMovie>{
+  async latest(): Promise<LatestMovie> {
     return await this.api.get<LatestMovie>(`${BASE_MOVIE}/latest`);
   }
 
-  async nowPlaying(options?: PageOption & LanguageOption & RegionOption): Promise<MoviesPlayingNow>{
+  async nowPlaying(
-    const params = parseOptions(options);
+    options?: PageOption & LanguageOption & RegionOption
-    return await this.api.get<MoviesPlayingNow>(`${BASE_MOVIE}/now_playing?${params}`);
+  ): Promise<MoviesPlayingNow> {
+    return await this.api.get<MoviesPlayingNow>(
+      `${BASE_MOVIE}/now_playing`,
+      options
+    );
   }
 
-  async popular(options?: PageOption): Promise<PopularMovies>{
+  async popular(options?: LanguageOption & PageOption): Promise<PopularMovies> {
-    const params = parseOptions(options);
+    return await this.api.get<PopularMovies>(`${BASE_MOVIE}/popular`, options);
-    return await this.api.get<PopularMovies>(`${BASE_MOVIE}/popular?${params}`);
   }
 
-  async topRated(options?: PageOption & LanguageOption & RegionOption): Promise<TopRatedMovies>{
+  async topRated(
-    const params = parseOptions(options);
+    options?: PageOption & LanguageOption & RegionOption
-    return await this.api.get<TopRatedMovies>(`${BASE_MOVIE}/top_rated?${params}`);
+  ): Promise<TopRatedMovies> {
+    return await this.api.get<TopRatedMovies>(
+      `${BASE_MOVIE}/top_rated`,
+      options
+    );
   }
 
-  async upcoming(options?: PageOption & LanguageOption & RegionOption): Promise<UpcomingMovies>{
+  async upcoming(
-    const params = parseOptions(options);
+    options?: PageOption & LanguageOption & RegionOption
-    return await this.api.get<UpcomingMovies>(`${BASE_MOVIE}/upcoming?${params}`);
+  ): Promise<UpcomingMovies> {
+    return await this.api.get<UpcomingMovies>(
+      `${BASE_MOVIE}/upcoming`,
+      options
+    );
   }
 }
-
-

src/endpoints/networks.ts

@@ -0,0 +1,23 @@
+import { NetworkDetails, NetworkImages } from '..';
+import { AlternativeNames } from './../types/companies';
+import { BaseEndpoint } from './base';
+
+export class NetworksEndpoint extends BaseEndpoint {
+  constructor(protected readonly accessToken: string) {
+    super(accessToken);
+  }
+
+  async details(id: number): Promise<NetworkDetails> {
+    return await this.api.get<NetworkDetails>(`/network/${id}`);
+  }
+
+  async alternativeNames(id: number): Promise<AlternativeNames> {
+    return await this.api.get<AlternativeNames>(
+      `/network/${id}/alternative_names`
+    );
+  }
+
+  async images(id: number): Promise<NetworkImages> {
+    return await this.api.get<NetworkImages>(`/network/${id}/images`);
+  }
+}

src/endpoints/people.ts

@@ -1,18 +1,21 @@
 import {
-  ChangeOptions,
+  AppendToResponse,
+  AppendToResponsePersonKey,
+  ChangeOption,
   ExternalIds,
-  Image,
   PageOption,
-  PeopleTranslations,
+  PeopleImages,
-  PersonChanges,
+  PersonTranslations,
   PersonCombinedCredits,
-  PersonDetail,
+  PersonDetails,
   PersonMovieCredit,
   PersonTvShowCredit,
   PopularPersons,
   TaggedImages,
+  Changes,
+  PersonChangeValue,
+  LanguageOption,
 } from '../types';
-import { parseOptions } from '../utils';
 import { BaseEndpoint } from './base';
 
 const BASE_PERSON = '/person';
@@ -22,50 +25,94 @@ export class PeopleEndpoint extends BaseEndpoint {
     super(accessToken);
   }
 
-  async details(id: number): Promise<PersonDetail> {
+  async details<T extends AppendToResponsePersonKey[] | undefined>(
-    return await this.api.get<PersonDetail>(`${BASE_PERSON}/${id}`);
+    id: number,
+    appendToResponse?: T,
+    language?: string
+  ) {
+    const options = {
+      append_to_response: appendToResponse
+        ? appendToResponse.join(',')
+        : undefined,
+      language: language,
+    };
+    return await this.api.get<AppendToResponse<PersonDetails, T, 'person'>>(
+      `${BASE_PERSON}/${id}`,
+      options
+    );
   }
 
-  async changes(id: number, options? : ChangeOptions): Promise<PersonChanges> {
+  async changes(
-    const params = parseOptions(options);
+    id: number,
-    return await this.api.get<PersonChanges>(`${BASE_PERSON}/${id}/changes?${params}`);
+    options?: ChangeOption
+  ): Promise<Changes<PersonChangeValue>> {
+    return await this.api.get<Changes<PersonChangeValue>>(
+      `${BASE_PERSON}/${id}/changes`,
+      options
+    );
   }
 
-  async movieCredits(id: number): Promise<PersonMovieCredit> {
+  async movieCredits(
-    return await this.api.get<PersonMovieCredit>(`${BASE_PERSON}/${id}/movie_credits`);
+    id: number,
+    options?: LanguageOption
+  ): Promise<PersonMovieCredit> {
+    return await this.api.get<PersonMovieCredit>(
+      `${BASE_PERSON}/${id}/movie_credits`,
+      options
+    );
   }
 
-  async tvShowCredits(id: number): Promise<PersonTvShowCredit> {
+  async tvShowCredits(
-    return await this.api.get<PersonTvShowCredit>(`${BASE_PERSON}/${id}/tv_credits`);
+    id: number,
+    options?: LanguageOption
+  ): Promise<PersonTvShowCredit> {
+    return await this.api.get<PersonTvShowCredit>(
+      `${BASE_PERSON}/${id}/tv_credits`,
+      options
+    );
   }
 
-  async combinedCredits(id: number) : Promise<PersonCombinedCredits> {
+  async combinedCredits(
-    return await this.api.get<PersonCombinedCredits>(`${BASE_PERSON}/${id}/combined_credits`);
+    id: number,
+    options?: LanguageOption
+  ): Promise<PersonCombinedCredits> {
+    return await this.api.get<PersonCombinedCredits>(
+      `${BASE_PERSON}/${id}/combined_credits`,
+      options
+    );
   }
 
-  async externalId(id: number): Promise<ExternalIds>{
+  async externalId(id: number): Promise<ExternalIds> {
     return await this.api.get<ExternalIds>(`${BASE_PERSON}/${id}/external_ids`);
   }
 
-  async images(id: number): Promise<{id: number, profiles: Image[]}>{
+  async images(id: number): Promise<PeopleImages> {
-    return await this.api.get<{id: number, profiles: Image[]}>(`${BASE_PERSON}/${id}/images`);
+    return await this.api.get<PeopleImages>(`${BASE_PERSON}/${id}/images`);
   }
 
-  async taggedImages(id: number, options?: PageOption): Promise<TaggedImages>{
+  async taggedImages(id: number, options?: PageOption): Promise<TaggedImages> {
-    const params = parseOptions(options);
+    return await this.api.get<TaggedImages>(
-    return await this.api.get<TaggedImages>(`${BASE_PERSON}/${id}/tagged_images?${params}`);
+      `${BASE_PERSON}/${id}/tagged_images`,
+      options
+    );
   }
 
-  async translation(id: number) : Promise<PeopleTranslations>{
+  async translation(id: number): Promise<PersonTranslations> {
-    return await this.api.get<PeopleTranslations>(`${BASE_PERSON}/${id}/translations`);
+    return await this.api.get<PersonTranslations>(
+      `${BASE_PERSON}/${id}/translations`
+    );
   }
 
-  async latest(): Promise<PersonDetail>{
+  async latest(): Promise<PersonDetails> {
-    return await this.api.get<PersonDetail>(`${BASE_PERSON}/latest`);
+    return await this.api.get<PersonDetails>(`${BASE_PERSON}/latest`);
   }
 
-  async popular(options?: PageOption): Promise<PopularPersons>{
+  async popular(
-    const params = parseOptions(options);
+    options?: LanguageOption & PageOption
-    return await this.api.get<PopularPersons>(`${BASE_PERSON}/popular?${params}`);
+  ): Promise<PopularPersons> {
+    return await this.api.get<PopularPersons>(
+      `${BASE_PERSON}/popular`,
+      options
+    );
   }
 }

src/endpoints/search.ts

@@ -1,7 +1,15 @@
 import { BaseEndpoint } from './base';
-import { Search } from '../types/search';
+import { MultiSearchResult, Search } from '../types/search';
-import { Collection, Company, Movie, Person, TV } from '../types';
+import {
-import { parseOptions } from '../utils';
+  Collection,
+  Company,
+  LanguageOption,
+  Movie,
+  PageOption,
+  Person,
+  RegionOption,
+  TV,
+} from '../types';
 
 const BASE_SEARCH = '/search';
 
@@ -10,18 +18,44 @@ export interface SearchOptions {
   page?: number;
 }
 
-export interface MovieSearchOptions extends SearchOptions {
+export interface MovieSearchOptions
+  extends SearchOptions,
+    LanguageOption,
+    PageOption,
+    RegionOption {
   include_adult?: boolean;
   year?: number;
   primary_release_year?: number;
 }
 
-export interface TvSearchOptions extends SearchOptions{
+export interface CollectionSearchOptions
+  extends SearchOptions,
+    LanguageOption,
+    PageOption,
+    RegionOption {
   include_adult?: boolean;
+}
+
+export interface TvSearchOptions
+  extends SearchOptions,
+    LanguageOption,
+    PageOption {
+  include_adult?: boolean;
+  year?: number;
   first_air_date_year?: number;
 }
 
-export interface PeopleSearchOptions extends SearchOptions{
+export interface PeopleSearchOptions
+  extends SearchOptions,
+    LanguageOption,
+    PageOption {
+  include_adult?: boolean;
+}
+
+export interface MultiSearchOptions
+  extends SearchOptions,
+    LanguageOption,
+    PageOption {
   include_adult?: boolean;
 }
 
@@ -30,35 +64,45 @@ export class SearchEndpoint extends BaseEndpoint {
     super(accessToken);
   }
 
-  async companies(options: SearchOptions): Promise<Search<Company>>{
+  async companies(options: SearchOptions): Promise<Search<Company>> {
-    const params = parseOptions(options);
+    return await this.api.get<Search<Company>>(
-    return await this.api.get<Search<Company>>(`${BASE_SEARCH}/company?${params}`);
+      `${BASE_SEARCH}/company`,
+      options
+    );
   }
 
-  async collections(options: SearchOptions): Promise<Search<Collection>>{
+  async collections(options: SearchOptions): Promise<Search<Collection>> {
-    const params = parseOptions(options);
+    return await this.api.get<Search<Collection>>(
-    return await this.api.get<Search<Collection>>(`${BASE_SEARCH}/collection?${params}`);
+      `${BASE_SEARCH}/collection`,
+      options
+    );
   }
 
-  async keywords(options: SearchOptions): Promise<Search<{ id: string, name: string }>>{
+  async keywords(
-    const params = parseOptions(options);
+    options: SearchOptions
-    return await this.api.get<Search<{ id: string, name: string }>>(`${BASE_SEARCH}/keyword?${params}`);
+  ): Promise<Search<{ id: string; name: string }>> {
+    return await this.api.get<Search<{ id: string; name: string }>>(
+      `${BASE_SEARCH}/keyword`,
+      options
+    );
   }
 
-  async movies(options: MovieSearchOptions): Promise<Search<Movie>>{
+  async movies(options: MovieSearchOptions): Promise<Search<Movie>> {
-    const params = parseOptions(options);
+    return await this.api.get<Search<Movie>>(`${BASE_SEARCH}/movie`, options);
-    return await this.api.get<Search<Movie>>(`${BASE_SEARCH}/movie?${params}`);
   }
 
-  async people(options: PeopleSearchOptions): Promise<Search<Person>>{
+  async people(options: PeopleSearchOptions): Promise<Search<Person>> {
-    const params = parseOptions(options);
+    return await this.api.get<Search<Person>>(`${BASE_SEARCH}/person`, options);
-    return await this.api.get<Search<Person>>(`${BASE_SEARCH}/person?${params}`);
   }
 
-  // TODO: Multi search
+  async tvShows(options: TvSearchOptions): Promise<Search<TV>> {
+    return await this.api.get<Search<TV>>(`${BASE_SEARCH}/tv`, options);
+  }
 
-  async tvShows(options: TvSearchOptions): Promise<Search<TV>>{
+  async multi(options: MultiSearchOptions): Promise<Search<MultiSearchResult>> {
-    const params = parseOptions(options);
+    return await this.api.get<Search<MultiSearchResult>>(
-    return await this.api.get<Search<TV>>(`${BASE_SEARCH}/tv?${params}`);
+      `${BASE_SEARCH}/multi`,
+      options
+    );
   }
 }

src/endpoints/trending.ts

@@ -1,4 +1,9 @@
-import { MediaType, TimeWindow, TrendingResults  } from '../types';
+import {
+  TrendingMediaType,
+  TimeWindow,
+  TrendingResults,
+  LanguageOption,
+} from '../types';
 import { BaseEndpoint } from './base';
 
 export class TrendingEndpoint extends BaseEndpoint {
@@ -6,9 +11,14 @@ export class TrendingEndpoint extends BaseEndpoint {
     super(accessToken);
   }
 
-  async trending<T extends MediaType>(mediaType : T, timeWindow: TimeWindow): Promise<TrendingResults<T>> {
+  async trending<T extends TrendingMediaType>(
-    return await this.api.get<TrendingResults<T>>(`/trending/${mediaType}/${timeWindow}`);
+    mediaType: T,
+    timeWindow: TimeWindow,
+    options?: LanguageOption
+  ): Promise<TrendingResults<T>> {
+    return await this.api.get<TrendingResults<T>>(
+      `/trending/${mediaType}/${timeWindow}`,
+      options
+    );
   }
 }
-
-

src/endpoints/tv-episode.ts

@@ -0,0 +1,111 @@
+import {
+  Episode,
+  EpisodeSelection,
+  LanguageOption,
+  ChangeOption,
+  TvEpisodeCredit,
+  ExternalIds,
+  Images,
+  TvEpisodeTranslations,
+  Videos,
+  AppendToResponse,
+  Changes,
+  TvEpisodeChangeValue,
+  AppendToResponseTvEpisodeKey,
+} from '..';
+import { BaseEndpoint } from './base';
+
+const BASE_EPISODE = (episodeSelection: EpisodeSelection): string => {
+  return `/tv/${episodeSelection.tvShowID}/season/${episodeSelection.seasonNumber}/episode/${episodeSelection.episodeNumber}`;
+};
+
+export interface TvEpisodeImageSearchOptions extends LanguageOption {
+  /**
+   * a list of ISO-639-1 values to query
+   */
+  include_image_language?: string[];
+}
+
+export interface TvEpisodeVideoSearchOptions extends LanguageOption {
+  /**
+   * a list of ISO-639-1 values to query
+   */
+  include_video_language?: string[];
+}
+
+export class TvEpisodesEndpoint extends BaseEndpoint {
+  constructor(accessToken: string) {
+    super(accessToken);
+  }
+
+  async details<T extends AppendToResponseTvEpisodeKey[] | undefined>(
+    episodeSelection: EpisodeSelection,
+    appendToResponse?: T,
+    options?: LanguageOption
+  ) {
+    const combinedOptions = {
+      append_to_response: appendToResponse
+        ? appendToResponse.join(',')
+        : undefined,
+      ...options,
+    };
+
+    return await this.api.get<
+      AppendToResponse<Omit<Episode, 'show_id'>, T, 'tvEpisode'>
+    >(`${BASE_EPISODE(episodeSelection)}`, combinedOptions);
+  }
+
+  async changes(episodeID: number, options?: ChangeOption) {
+    return await this.api.get<Changes<TvEpisodeChangeValue>>(
+      `/tv/episode/${episodeID}/changes`,
+      options
+    );
+  }
+
+  async credits(episodeSelection: EpisodeSelection, options?: LanguageOption) {
+    return await this.api.get<TvEpisodeCredit>(
+      `${BASE_EPISODE(episodeSelection)}/credits`,
+      options
+    );
+  }
+
+  async externalIds(episodeSelection: EpisodeSelection) {
+    return await this.api.get<ExternalIds>(
+      `${BASE_EPISODE(episodeSelection)}/external_ids`
+    );
+  }
+
+  async images(
+    episodeSelection: EpisodeSelection,
+    options?: TvEpisodeImageSearchOptions
+  ) {
+    const computedOptions = {
+      include_image_language: options?.include_image_language?.join(','),
+      language: options?.language,
+    };
+    return await this.api.get<Images>(
+      `${BASE_EPISODE(episodeSelection)}/images`,
+      computedOptions
+    );
+  }
+
+  async translations(episodeSelection: EpisodeSelection) {
+    return await this.api.get<TvEpisodeTranslations>(
+      `${BASE_EPISODE(episodeSelection)}/translations`
+    );
+  }
+
+  async videos(
+    episodeSelection: EpisodeSelection,
+    options?: TvEpisodeVideoSearchOptions
+  ) {
+    const computedOptions = {
+      include_video_language: options?.include_video_language?.join(','),
+      language: options?.language,
+    };
+    return await this.api.get<Videos>(
+      `${BASE_EPISODE(episodeSelection)}/videos`,
+      computedOptions
+    );
+  }
+}

src/endpoints/tv-seasons.ts

@@ -0,0 +1,131 @@
+import {
+  ChangeOption,
+  Changes,
+  Credits,
+  ExternalIds,
+  Images,
+  LanguageOption,
+  TvSeasonChangeValue,
+  SeasonDetails,
+  SeasonSelection,
+  Translations,
+  Videos,
+  AppendToResponseTvSeasonKey,
+  AppendToResponse,
+  AggregateCredits,
+} from '..';
+import { BaseEndpoint } from './base';
+
+const BASE_SEASON = (seasonSelection: SeasonSelection): string => {
+  return `/tv/${seasonSelection.tvShowID}/season/${seasonSelection.seasonNumber}`;
+};
+
+export interface TvSeasonImageSearchOptions extends LanguageOption {
+  /**
+   * a list of ISO-639-1 values to query
+   */
+  include_image_language?: string[];
+}
+
+export interface TvSeasonVideoSearchOptions extends LanguageOption {
+  /**
+   * a list of ISO-639-1 values to query
+   */
+  include_video_language?: string[];
+}
+
+export class TvSeasonsEndpoint extends BaseEndpoint {
+  constructor(accessToken: string) {
+    super(accessToken);
+  }
+
+  async details<T extends AppendToResponseTvSeasonKey[] | undefined>(
+    seasonSelection: SeasonSelection,
+    appendToResponse?: T,
+    options?: LanguageOption
+  ) {
+    const combinedOptions = {
+      append_to_response: appendToResponse
+        ? appendToResponse.join(',')
+        : undefined,
+      ...options,
+    };
+
+    return await this.api.get<AppendToResponse<SeasonDetails, T, 'tvSeason'>>(
+      `${BASE_SEASON(seasonSelection)}`,
+      combinedOptions
+    );
+  }
+
+  async aggregateCredits(
+    seasonSelection: SeasonSelection,
+    options?: LanguageOption
+  ) {
+    return await this.api.get<AggregateCredits>(
+      `${BASE_SEASON(seasonSelection)}/aggregate_credits`,
+      options
+    );
+  }
+
+  async changes(seasonId: number, options?: ChangeOption) {
+    return await this.api.get<Changes<TvSeasonChangeValue>>(
+      `/tv/season/${seasonId}/changes`,
+      options
+    );
+  }
+
+  async credits(seasonSelection: SeasonSelection, options?: LanguageOption) {
+    return await this.api.get<Credits>(
+      `${BASE_SEASON(seasonSelection)}/credits`,
+      options
+    );
+  }
+
+  async externalIds(
+    seasonSelection: SeasonSelection,
+    options?: LanguageOption
+  ) {
+    return await this.api.get<ExternalIds>(
+      `${BASE_SEASON(seasonSelection)}/external_ids`,
+      options
+    );
+  }
+
+  async images(
+    seasonSelection: SeasonSelection,
+    options?: TvSeasonImageSearchOptions
+  ) {
+    const computedOptions = {
+      include_image_language: options?.include_image_language?.join(','),
+      language: options?.language,
+    };
+    return await this.api.get<Images>(
+      `${BASE_SEASON(seasonSelection)}/images`,
+      computedOptions
+    );
+  }
+
+  async videos(
+    seasonSelection: SeasonSelection,
+    options?: TvSeasonVideoSearchOptions
+  ) {
+    const computedOptions = {
+      include_video_language: options?.include_video_language?.join(','),
+      language: options?.language,
+    };
+    return await this.api.get<Videos>(
+      `${BASE_SEASON(seasonSelection)}/videos`,
+      computedOptions
+    );
+  }
+
+  async translations(
+    seasonSelection: SeasonSelection,
+    options?: LanguageOption
+  ) {
+    return await this.api.get<Translations>(
+      `${BASE_SEASON(seasonSelection)}/translations`,
+      options
+    );
+  }
+}

src/endpoints/tv-shows.ts

@@ -1,7 +1,11 @@
 import { BaseEndpoint } from './base';
 import {
+  AggregateCredits,
   AlternativeTitles,
-  ChangeOptions,
+  AppendToResponse,
+  AppendToResponseTvKey,
+  ChangeOption,
+  Changes,
   ContentRatings,
   Credits,
   EpisodeGroups,
@@ -14,124 +18,197 @@ import {
   PageOption,
   PopularTvShows,
   Recommendations,
-  RegionOption,
   Reviews,
   ScreenedTheatrically,
   SeasonDetails,
   SimilarTvShows,
+  TimezoneOption,
   TopRatedTvShows,
   Translations,
-  TvShowChanges,
+  TvShowImageOptions,
+  TvShowVideoOptions,
+  TvShowChangeValue,
   TvShowDetails,
   TvShowsAiringToday,
   Videos,
   WatchProviders,
 } from '../types';
-import { parseOptions } from '../utils';
 
 const BASE_TV = '/tv';
 
-export class TvShowsEndpoint extends BaseEndpoint{
+export class TvShowsEndpoint extends BaseEndpoint {
   constructor(protected readonly accessToken: string) {
     super(accessToken);
   }
 
-  async details(id: number): Promise<TvShowDetails>{
+  async details<T extends AppendToResponseTvKey[] | undefined>(
-    return await this.api.get<TvShowDetails>(`${BASE_TV}/${id}`);
+    id: number,
+    appendToResponse?: T,
+    language?: string
+  ) {
+    const options = {
+      append_to_response: appendToResponse
+        ? appendToResponse.join(',')
+        : undefined,
+      language: language,
+    };
+    return await this.api.get<AppendToResponse<TvShowDetails, T, 'tvShow'>>(
+      `${BASE_TV}/${id}`,
+      options
+    );
   }
 
-  async alternativeTitles(id: number): Promise<AlternativeTitles>{
+  async alternativeTitles(id: number): Promise<AlternativeTitles> {
-    return await this.api.get<AlternativeTitles>(`${BASE_TV}/${id}/alternative_titles`);
+    return await this.api.get<AlternativeTitles>(
+      `${BASE_TV}/${id}/alternative_titles`
+    );
   }
 
-  async changes(id: number, options?: ChangeOptions): Promise<TvShowChanges>{
+  async changes(
-    const params = parseOptions(options);
+    id: number,
-    return await this.api.get<TvShowChanges>(`${BASE_TV}/${id}/changes?${params}`);
+    options?: ChangeOption
+  ): Promise<Changes<TvShowChangeValue>> {
+    return await this.api.get<Changes<TvShowChangeValue>>(
+      `${BASE_TV}/${id}/changes`,
+      options
+    );
   }
 
-  async contentRatings(id: number): Promise<ContentRatings>{
+  async contentRatings(id: number): Promise<ContentRatings> {
-    return await this.api.get<ContentRatings>(`${BASE_TV}/${id}/content_ratings`);
+    return await this.api.get<ContentRatings>(
+      `${BASE_TV}/${id}/content_ratings`
+    );
   }
 
-  async credits(id: number): Promise<Credits>{
+  async aggregateCredits(
-    return await this.api.get<Credits>(`${BASE_TV}/${id}/credits`);
+    id: number,
+    options?: LanguageOption
+  ): Promise<AggregateCredits> {
+    return await this.api.get<AggregateCredits>(
+      `${BASE_TV}/${id}/aggregate_credits`,
+      options
+    );
   }
 
-  async season(tvId: number, seasonNumber: number): Promise<SeasonDetails>{
+  async credits(id: number, options?: LanguageOption): Promise<Credits> {
-    return await this.api.get<SeasonDetails>(`${BASE_TV}/${tvId}/season/${seasonNumber}`);
+    return await this.api.get<Credits>(`${BASE_TV}/${id}/credits`, options);
   }
 
-  async episodeGroups(id: number): Promise<EpisodeGroups>{
+  async season(tvId: number, seasonNumber: number): Promise<SeasonDetails> {
+    return await this.api.get<SeasonDetails>(
+      `${BASE_TV}/${tvId}/season/${seasonNumber}`
+    );
+  }
+
+  async episodeGroups(id: number): Promise<EpisodeGroups> {
     return await this.api.get<EpisodeGroups>(`${BASE_TV}/${id}/episode_groups`);
   }
 
-  async externalIds(id: number): Promise<ExternalIds>{
+  async externalIds(id: number): Promise<ExternalIds> {
     return await this.api.get<ExternalIds>(`${BASE_TV}/${id}/external_ids`);
   }
 
-  async images(id: number): Promise<Images>{
+  async images(id: number, options?: TvShowImageOptions): Promise<Images> {
-    return await this.api.get<Images>(`${BASE_TV}/${id}/images`);
+    const computedOptions = {
+      include_image_language: options?.include_image_language?.join(','),
+      language: options?.language,
+    };
+    return await this.api.get<Images>(
+      `${BASE_TV}/${id}/images`,
+      computedOptions
+    );
   }
 
-  async keywords(id: number): Promise<Keywords>{
+  async keywords(id: number): Promise<Keywords> {
     return await this.api.get<Keywords>(`${BASE_TV}/${id}/keywords`);
   }
 
-  async recommendations(id: number, options?: PageOption): Promise<Recommendations>{
+  async recommendations(
-    const params = parseOptions(options);
+    id: number,
-    return await this.api.get<Recommendations>(`${BASE_TV}/${id}/recommendations?${params}`);
+    options?: LanguageOption & PageOption
+  ): Promise<Recommendations> {
+    return await this.api.get<Recommendations>(
+      `${BASE_TV}/${id}/recommendations`,
+      options
+    );
   }
 
-  async reviews(id: number, options?: PageOption): Promise<Reviews>{
+  async reviews(
-    const params = parseOptions(options);
+    id: number,
-    return await this.api.get<Reviews>(`${BASE_TV}/${id}/reviews?${params}`);
+    options?: LanguageOption & PageOption
+  ): Promise<Reviews> {
+    return await this.api.get<Reviews>(`${BASE_TV}/${id}/reviews`, options);
   }
 
-  async screenedTheatrically(id: number): Promise<ScreenedTheatrically>{
+  async screenedTheatrically(id: number): Promise<ScreenedTheatrically> {
-    return await this.api.get<ScreenedTheatrically>(`${BASE_TV}/${id}/screened_theatrically`);
+    return await this.api.get<ScreenedTheatrically>(
+      `${BASE_TV}/${id}/screened_theatrically`
+    );
   }
 
-  async similar(id: number, options?: PageOption): Promise<SimilarTvShows>{
+  async similar(
-    const params = parseOptions(options);
+    id: number,
-    return await this.api.get<SimilarTvShows>(`${BASE_TV}/${id}/similar?${params}`);
+    options?: LanguageOption & PageOption
+  ): Promise<SimilarTvShows> {
+    return await this.api.get<SimilarTvShows>(
+      `${BASE_TV}/${id}/similar`,
+      options
+    );
   }
 
-  async translations(id: number): Promise<Translations>{
+  async translations(id: number): Promise<Translations> {
     return await this.api.get<Translations>(`${BASE_TV}/${id}/translations`);
   }
 
-  async videos(id: number): Promise<Videos>{
+  async videos(id: number, options?: TvShowVideoOptions): Promise<Videos> {
-    return await this.api.get<Videos>(`${BASE_TV}/${id}/videos`);
+    const computedOptions = {
+      include_video_language: options?.include_video_language?.join(','),
+      language: options?.language,
+    };
+    return await this.api.get<Videos>(
+      `${BASE_TV}/${id}/videos`,
+      computedOptions
+    );
   }
 
   /**
-     * Powered by JustWatch
+   * Powered by JustWatch
-     * @param id
+   * @param id
-     */
+   */
-  async watchProviders(id: number): Promise<WatchProviders>{
+  async watchProviders(id: number): Promise<WatchProviders> {
-    return await this.api.get<WatchProviders>(`${BASE_TV}/${id}/watch/providers`);
+    return await this.api.get<WatchProviders>(
+      `${BASE_TV}/${id}/watch/providers`
+    );
   }
 
-  async latest(): Promise<LatestTvShows>{
+  async latest(): Promise<LatestTvShows> {
     return await this.api.get<LatestTvShows>(`${BASE_TV}/latest`);
   }
 
-  async onTheAir(): Promise<OnTheAir>{
+  async onTheAir(
-    return await this.api.get<OnTheAir>(`${BASE_TV}/on_the_air`);
+    options?: PageOption & LanguageOption & TimezoneOption
+  ): Promise<OnTheAir> {
+    return await this.api.get<OnTheAir>(`${BASE_TV}/on_the_air`, options);
   }
 
-  async airingToday(options?: PageOption & LanguageOption & RegionOption): Promise<TvShowsAiringToday>{
+  async airingToday(
-    const params = parseOptions(options);
+    options?: PageOption & LanguageOption & TimezoneOption
-    return await this.api.get<TvShowsAiringToday>(`${BASE_TV}/airing_today?${params}`);
+  ): Promise<TvShowsAiringToday> {
+    return await this.api.get<TvShowsAiringToday>(
+      `${BASE_TV}/airing_today`,
+      options
+    );
   }
 
-  async popular(options?: PageOption & LanguageOption & RegionOption): Promise<PopularTvShows>{
+  async popular(
-    const params = parseOptions(options);
+    options?: PageOption & LanguageOption
-    return await this.api.get<PopularTvShows>(`${BASE_TV}/popular?${params}`);
+  ): Promise<PopularTvShows> {
+    return await this.api.get<PopularTvShows>(`${BASE_TV}/popular`, options);
   }
 
-  async topRated(options?: PageOption & LanguageOption & RegionOption): Promise<TopRatedTvShows>{
+  async topRated(
-    const params = parseOptions(options);
+    options?: PageOption & LanguageOption
-    return await this.api.get<TopRatedTvShows>(`${BASE_TV}/top_rated?${params}`);
+  ): Promise<TopRatedTvShows> {
+    return await this.api.get<TopRatedTvShows>(`${BASE_TV}/top_rated`, options);
   }
 }

src/index.ts

@@ -1,6 +1,6 @@
-import TMDB from './tmdb';
+import { TMDB } from './tmdb';
 
 export * from './types';
 export * from './utils';
 
-export default TMDB;
+export { TMDB };

src/tmdb.ts

@@ -15,9 +15,13 @@ import {
   FindEndpoint,
   KeywordsEndpoint,
   CollectionsEndpoint,
+  TvSeasonsEndpoint,
+  TvEpisodesEndpoint,
 } from './endpoints';
+import { CompaniesEndpoint } from './endpoints/companies';
+import { NetworksEndpoint } from './endpoints/networks';
 
-export default class TMDB {
+export class TMDB {
   private readonly accessToken: string;
 
   constructor(accessToken: string) {
@@ -44,47 +48,63 @@ export default class TMDB {
     return new CreditsEndpoint(this.accessToken);
   }
 
-  get search(): SearchEndpoint{
+  get companies(): CompaniesEndpoint {
+    return new CompaniesEndpoint(this.accessToken);
+  }
+
+  get networks(): NetworksEndpoint {
+    return new NetworksEndpoint(this.accessToken);
+  }
+
+  get search(): SearchEndpoint {
     return new SearchEndpoint(this.accessToken);
   }
 
-  get genres(): GenreEndpoint{
+  get genres(): GenreEndpoint {
     return new GenreEndpoint(this.accessToken);
   }
 
-  get movies(): MoviesEndpoint{
+  get movies(): MoviesEndpoint {
     return new MoviesEndpoint(this.accessToken);
   }
 
-  get tvShows(): TvShowsEndpoint{
+  get tvShows(): TvShowsEndpoint {
     return new TvShowsEndpoint(this.accessToken);
   }
 
-  get discover(): DiscoverEndpoint{
+  get tvEpisode(): TvEpisodesEndpoint {
+    return new TvEpisodesEndpoint(this.accessToken);
+  }
+
+  get discover(): DiscoverEndpoint {
     return new DiscoverEndpoint(this.accessToken);
   }
 
-  get people(): PeopleEndpoint{
+  get people(): PeopleEndpoint {
     return new PeopleEndpoint(this.accessToken);
   }
 
-  get review(): ReviewEndpoint{
+  get review(): ReviewEndpoint {
     return new ReviewEndpoint(this.accessToken);
   }
 
-  get trending(): TrendingEndpoint{
+  get trending(): TrendingEndpoint {
     return new TrendingEndpoint(this.accessToken);
   }
 
-  get find() : FindEndpoint{
+  get find(): FindEndpoint {
     return new FindEndpoint(this.accessToken);
   }
 
-  get keywords() : KeywordsEndpoint{
+  get keywords(): KeywordsEndpoint {
     return new KeywordsEndpoint(this.accessToken);
   }
 
-  get collections() : CollectionsEndpoint{
+  get collections(): CollectionsEndpoint {
     return new CollectionsEndpoint(this.accessToken);
   }
+
+  get tvSeasons(): TvSeasonsEndpoint {
+    return new TvSeasonsEndpoint(this.accessToken);
+  }
 }

src/types/account.ts

@@ -0,0 +1,17 @@
+export interface Gravatar {
+  hash: string;
+}
+
+export interface Avatar {
+  gravatar: Gravatar;
+}
+
+export interface AccountDetails {
+  avatar: Avatar;
+  id: number;
+  include_adult: boolean;
+  iso_3166_1: string;
+  iso_639_1: string;
+  name: string;
+  username: string;
+}

src/types/certification.ts

@@ -6,14 +6,14 @@ export interface Certification {
 
 export interface Certifications {
   certifications: {
-    US: Certification[],
+    US: Certification[];
-    CA: Certification[],
+    CA: Certification[];
-    DE: Certification[],
+    DE: Certification[];
-    GB: Certification[],
+    GB: Certification[];
-    AU: Certification[],
+    AU: Certification[];
-    BR: Certification[],
+    BR: Certification[];
-    FR: Certification[],
+    FR: Certification[];
-    NZ: Certification[],
+    NZ: Certification[];
-    IN: Certification[],
+    IN: Certification[];
-  }
+  };
 }

src/types/changes.ts

@@ -1,17 +1,29 @@
-export interface Change {
+export interface MediaChange {
   id: number;
   adult: boolean | undefined;
 }
 
-export interface Changes{
+export interface MediaChanges {
-  results: Change[];
+  results: MediaChange[];
   page: number;
   total_pages: number;
   total_results: number;
 }
 
-export interface ChangeOptions {
+export interface Changes<T> {
-  end_date?: string;
+  changes: Change<T>[];
-  start_date?: string;
+}
-  page?: number;
+
+export interface Change<T> {
+  key: string;
+  items: ChangeItem<T>[];
+}
+
+export interface ChangeItem<T> {
+  id: string;
+  action: string;
+  time: string;
+  value: T;
+  iso_639_1: string;
+  original_value: T;
 }

src/types/collections.ts

@@ -1,4 +1,4 @@
-import { Movie } from '.';
+import { LanguageOption, Movie } from '.';
 
 export interface Collection {
   id: number;
@@ -12,5 +12,12 @@ export interface Collection {
 }
 
 export interface DetailedCollection extends Collection {
-  parts: Movie[]
+  parts: Movie[];
+}
+
+export interface CollectionImageOptions extends LanguageOption {
+  /**
+   * a list of ISO-639-1 values to query
+   */
+  include_image_language?: string[];
 }

src/types/companies.ts

@@ -0,0 +1,33 @@
+import { Image } from '.';
+
+export interface CompanyDetails {
+  description: string;
+  headquarters: string;
+  homepage: string;
+  id: number;
+  logo_path: string;
+  name: string;
+  origin_country: string;
+  parent_company: ParentCompany;
+}
+
+export interface ParentCompany {
+  name: string;
+  id: number;
+  logo_path: string;
+}
+
+export interface AlternativeNames {
+  id: number;
+  results: Name[];
+}
+
+export interface Name {
+  name: string;
+  type: string;
+}
+
+export interface CompanyImages {
+  id: number;
+  logos: Image[];
+}

src/types/configuration.ts

@@ -1,5 +1,4 @@
-
+export interface ImageConfiguration {
-export interface Images {
   base_url: string;
   secure_base_url: string;
   backdrop_sizes: BackdropSizes[];
@@ -10,51 +9,49 @@ export interface Images {
 }
 
 export interface Configuration {
-  images: Images;
+  images: ImageConfiguration;
   change_keys: ChangeKeys[];
 }
 
-
 export const enum BackdropSizes {
   W300 = 'w300',
   W780 = 'w780',
   W1280 = 'w1280',
-  ORIGINAL = 'original'
+  ORIGINAL = 'original',
 }
 
 export const enum LogoSizes {
-  W45= 'w45',
+  W45 = 'w45',
-  W92= 'w92',
+  W92 = 'w92',
-  W154= 'w154',
+  W154 = 'w154',
-  W185= 'w185',
+  W185 = 'w185',
   W300 = 'w300',
   W500 = 'w500',
-  ORIGINAL = 'original'
+  ORIGINAL = 'original',
 }
 
 export const enum PosterSizes {
-  W92= 'w92',
+  W92 = 'w92',
-  W154= 'w154',
+  W154 = 'w154',
-  W185='w185',
+  W185 = 'w185',
   W300 = 'w300',
   W500 = 'w500',
   W780 = 'w780',
-  ORIGINAL = 'original'
+  ORIGINAL = 'original',
 }
 
 export const enum ProfileSizes {
   W45 = 'w45',
   W185 = 'w185',
   W632 = 'w632',
-  ORIGINAL = 'original'
+  ORIGINAL = 'original',
 }
 
-
 export const enum StillSizes {
-  W92= 'w92',
+  W92 = 'w92',
   W185 = 'w185',
   W300 = 'w300',
-  ORIGINAL = 'original'
+  ORIGINAL = 'original',
 }
 
 export const enum ChangeKeys {
@@ -110,5 +107,5 @@ export const enum ChangeKeys {
   TVRAGE_ID = 'tvrage_id',
   TYPE = 'type',
   VIDEO = 'video',
-  VIDEOS = 'videos'
+  VIDEOS = 'videos',
 }

src/types/credits.ts

@@ -6,10 +6,9 @@ export interface CreditSeason {
   season_number?: number;
 }
 
-
+export interface Media {
-export interface Media{
   i?: number;
-  name?:string;
+  name?: string;
   first_air_date?: string;
   vote_count?: number;
   overview?: string;
@@ -87,8 +86,6 @@ export interface ImageCollection {
   backdrops: Image[];
   posters: Image[];
 }
-
-
 export interface Video {
   id: string;
   iso_639_1: string;
@@ -103,4 +100,50 @@ export interface Video {
 export interface Videos {
   id: number;
   results: Video[];
-}
+}
+
+export interface AggregateCredits {
+  id: number;
+  cast: AggregateCast[];
+  crew: AggregateCrew[];
+}
+
+export interface CastRole {
+  credit_id: string;
+  character: string;
+  episode_count: number;
+}
+
+export interface AggregateCast {
+  adult: boolean;
+  gender: number;
+  id: number;
+  known_for_department: string;
+  name: string;
+  original_name: string;
+  popularity: number;
+  profile_path: string;
+  roles: CastRole[];
+  total_episode_count: number;
+  order: number;
+}
+
+export interface CrewJob {
+  credit_id: string;
+  job: string;
+  episode_count: number;
+}
+
+export interface AggregateCrew {
+  adult: boolean;
+  gender: number;
+  id: number;
+  known_for_department: string;
+  name: string;
+  original_name: string;
+  popularity: number;
+  profile_path: string;
+  jobs: CrewJob[];
+  department: string;
+  total_episode_count: number;
+}

src/types/discover.ts

@@ -1,29 +1,29 @@
 import { Movie, TV } from '.';
 
 export type SortOption =
-	| 'popularity.asc'
+  | 'popularity.asc'
-	| 'popularity.desc'
+  | 'popularity.desc'
-	| 'release_date.asc'
+  | 'release_date.asc'
-	| 'release_date.desc'
+  | 'release_date.desc'
-	| 'revenue.asc'
+  | 'revenue.asc'
-	| 'revenue.desc'
+  | 'revenue.desc'
-	| 'primary_release_date.asc'
+  | 'primary_release_date.asc'
-	| 'primary_release_date.desc'
+  | 'primary_release_date.desc'
-	| 'original_title.asc'
+  | 'original_title.asc'
-	| 'original_title.desc'
+  | 'original_title.desc'
-	| 'vote_average.asc'
+  | 'vote_average.asc'
-	| 'vote_average.desc'
+  | 'vote_average.desc'
-	| 'vote_count.asc'
+  | 'vote_count.asc'
-	| 'vote_count.desc';
+  | 'vote_count.desc';
 
-export interface MovieDiscoverResult{
+export interface MovieDiscoverResult {
   page: number;
   results: Movie[];
   total_results: number;
   total_pages: number;
 }
 
-export interface TvShowDiscoverResult{
+export interface TvShowDiscoverResult {
   page: number;
   results: TV[];
   total_results: number;

src/types/index.ts

@@ -1,8 +1,10 @@
 export * from './options';
 export * from './certification';
-export *  from './credits';
+export * from './credits';
+export * from './companies';
+export * from './networks';
 export * from './configuration';
-export *  from './changes';
+export * from './changes';
 export * from './movies';
 export * from './search';
 export * from './tv-shows';
@@ -14,6 +16,16 @@ export * from './trending';
 export * from './find';
 export * from './keywords';
 export * from './collections';
+export * from './tv-episode';
+export * from './tv-seasons';
+
+export interface ErrorResponse {
+  status_code: number;
+  status_message: string;
+  success: boolean;
+}
+
+export type MediaType = 'movie' | 'tv' | 'person';
 
 export interface AuthorDetails {
   name: string;
@@ -22,23 +34,7 @@ export interface AuthorDetails {
   rating?: number;
 }
 
-export interface KnownFor {
+export type KnownFor = MovieWithMediaType | TVWithMediaType;
-  id: number;
-  overview: string;
-  release_date: string;
-  video: boolean;
-  adult: boolean;
-  backdrop_path: string;
-  media_type: string;
-  genre_ids: number[];
-  title: string;
-  original_language: string;
-  original_title: string;
-  poster_path: string;
-  vote_count: number;
-  vote_average: number;
-  popularity: number;
-}
 
 export interface Person {
   id: number;
@@ -51,6 +47,10 @@ export interface Person {
   popularity: number;
 }
 
+export interface PersonWithMediaType extends Person {
+  media_type: 'person';
+}
+
 export interface Movie {
   id: number;
   poster_path: string;
@@ -68,6 +68,10 @@ export interface Movie {
   vote_average: number;
 }
 
+export interface MovieWithMediaType extends Movie {
+  media_type: 'movie';
+}
+
 export interface Company {
   id: number;
   logo_path: string;
@@ -77,7 +81,7 @@ export interface Company {
 
 export interface TV {
   id: number;
-  name:string;
+  name: string;
   first_air_date: string;
   backdrop_path: string;
   genre_ids: number[];
@@ -91,6 +95,10 @@ export interface TV {
   vote_average: number;
 }
 
+export interface TVWithMediaType extends TV {
+  media_type: 'tv';
+}
+
 export interface Genre {
   id: number;
   name: string;
@@ -122,27 +130,27 @@ export interface SpokenLanguage {
   name: string;
 }
 
-export interface ContentRatings{
+export interface ContentRatings {
   results: ContentRatingsResult[];
   id: number;
 }
 
 export interface ContentRatingsResult {
+  descriptor: unknown[];
   iso_3166_1: string;
   rating: string;
 }
 
-
 export interface Recommendation {
   adult: boolean;
-  backdrop_path?: any;
+  backdrop_path?: string;
   genre_ids: number[];
   id: number;
   original_language: string;
   original_title: string;
   overview: string;
   release_date: string;
-  poster_path?: any;
+  poster_path?: string;
   popularity: number;
   title: string;
   video: boolean;
@@ -150,7 +158,6 @@ export interface Recommendation {
   vote_count: number;
 }
 
-
 export interface Recommendations {
   page: number;
   results: Recommendation[];
@@ -176,7 +183,6 @@ export interface Reviews {
   total_results: number;
 }
 
-
 export interface TranslationData {
   title: string;
   overview: string;
@@ -196,7 +202,7 @@ export interface Translations {
   translations: Translation[];
 }
 
-export interface Image{
+export interface Image {
   aspect_ratio: number;
   file_path: string;
   height: number;
@@ -204,4 +210,11 @@ export interface Image{
   vote_average: number;
   vote_count: number;
   width: number;
-}
+}
+
+export interface Images {
+  id: number;
+  backdrops: Image[];
+  logos: Image[];
+  posters: Image[];
+}

src/types/keywords.ts

@@ -1,18 +1,19 @@
 import { Movie } from '.';
+import { PageOption } from './options';
 
-export interface KeywordsOptions {
+export interface KeywordsOptions extends PageOption {
   include_adult?: boolean;
   language?: string;
 }
 
-export interface BelongingMovies{
+export interface BelongingMovies {
   page: number;
   results: Movie[];
   total_results: number;
   total_pages: number;
 }
 
-export interface Keyword{
+export interface Keyword {
   id: number;
   name: string;
 }
@@ -20,4 +21,4 @@ export interface Keyword{
 export interface Keywords {
   id: number;
   keywords: Keyword[];
-}
+}

src/types/movies.ts

@@ -1,9 +1,22 @@
-import { Genre, Movie, ProductionCompany, ProductionCountry, SpokenLanguage } from './';
+import {
+  Genre,
+  Movie,
+  ProductionCompany,
+  ProductionCountry,
+  SpokenLanguage,
+} from './';
+
+export interface BelongsToCollection {
+  id: number;
+  name: string;
+  poster_path: string;
+  backdrop_path: string;
+}
 
 export interface MovieDetails {
   adult: boolean;
   backdrop_path: string;
-  belongs_to_collection?: any;
+  belongs_to_collection?: BelongsToCollection;
   budget: number;
   genres: Genre[];
   homepage: string;
@@ -13,7 +26,7 @@ export interface MovieDetails {
   original_title: string;
   overview: string;
   popularity: number;
-  poster_path?: any;
+  poster_path?: string;
   production_companies: ProductionCompany[];
   production_countries: ProductionCountry[];
   release_date: string;
@@ -34,7 +47,7 @@ export enum ReleaseDateType {
   'Theatrical',
   'Digital',
   'Physical',
-  'TV'
+  'TV',
 }
 
 export interface ReleaseDate {
@@ -55,7 +68,6 @@ export interface ReleaseDates {
   results: ReleaseDateResult[];
 }
 
-
 export interface SimilarMovies {
   page: number;
   results: Movie[];
@@ -82,29 +94,10 @@ export interface MovieLists {
   total_results: number;
 }
 
-
-export interface MovieChangeItem {
-  id: string;
-  action: string;
-  time: string;
-  iso_639_1: string;
-  value: string;
-  original_value: string;
-}
-
-export interface MovieChange {
-  key: string;
-  items: MovieChangeItem[];
-}
-
-export interface MovieChanges {
-  changes: MovieChange[];
-}
-
 export interface LatestMovie {
   adult: boolean;
-  backdrop_path?: any;
+  backdrop_path?: string;
-  belongs_to_collection?: any;
+  belongs_to_collection?: BelongsToCollection;
   budget: number;
   genres: Genre[];
   homepage: string;
@@ -115,12 +108,12 @@ export interface LatestMovie {
   overview: string;
   popularity: number;
   poster_path: string;
-  production_companies: any[];
+  production_companies: ProductionCompany[];
-  production_countries: any[];
+  production_countries: ProductionCountry[];
   release_date: string;
   revenue: number;
   runtime: number;
-  spoken_languages: any[];
+  spoken_languages: SpokenLanguage[];
   status: string;
   tagline: string;
   title: string;
@@ -129,7 +122,6 @@ export interface LatestMovie {
   vote_count: number;
 }
 
-
 export interface Dates {
   maximum: string;
   minimum: string;
@@ -163,3 +155,14 @@ export interface UpcomingMovies {
   total_results: number;
   total_pages: number;
 }
+
+export type MovieChangeValue =
+  | string
+  | {
+      person_id: number;
+      character: string;
+      order: number;
+      cast_id: number;
+      credit_id: string;
+    }
+  | unknown;

src/types/networks.ts

@@ -0,0 +1,15 @@
+import { Image } from '.';
+
+export interface NetworkDetails {
+  headquarters: string;
+  homepage: string;
+  id: number;
+  logo_path: string;
+  name: string;
+  origin_country: string;
+}
+
+export interface NetworkImages {
+  id: number;
+  logos: Image[];
+}

src/types/options.ts

@@ -1,3 +1,37 @@
+import {
+  AlternativeTitles,
+  Changes,
+  ContentRatings,
+  Credits,
+  EpisodeGroups,
+  ExternalIds,
+  Images,
+  Keywords,
+  MovieLists,
+  PeopleImages,
+  PersonTranslations,
+  PersonCombinedCredits,
+  PersonMovieCredit,
+  PersonTvShowCredit,
+  Recommendations,
+  ReleaseDates,
+  Reviews,
+  ScreenedTheatrically,
+  SimilarMovies,
+  SimilarTvShows,
+  TaggedImages,
+  Translations,
+  Videos,
+  WatchProviders,
+  PersonChangeValue,
+  MovieChangeValue,
+  TvShowChangeValue,
+  TvEpisodeChangeValue,
+  TvEpisodeCredit,
+  TvEpisodeTranslations,
+  TvSeasonChangeValue,
+} from '.';
+
 export interface LanguageOption {
   language?: string;
 }
@@ -6,6 +40,201 @@ export interface RegionOption {
   region?: string;
 }
 
+export interface TimezoneOption {
+  timezone?: string;
+}
+
 export interface PageOption {
   page?: number;
 }
+
+export interface ChangeOption extends PageOption {
+  start_date?: Date;
+  end_date?: Date;
+}
+
+export type AppendToResponseMovieKey =
+  | 'images'
+  | 'videos'
+  | 'credits'
+  | 'recommendations'
+  | 'reviews'
+  | 'changes'
+  | 'similar'
+  | 'lists'
+  | 'release_dates'
+  | 'alternative_titles'
+  | 'external_ids'
+  | 'translations'
+  | 'watch/providers'
+  | 'keywords';
+
+export type AppendToResponseTvKey =
+  | 'content_ratings'
+  | 'images'
+  | 'videos'
+  | 'credits'
+  | 'recommendations'
+  | 'reviews'
+  | 'changes'
+  | 'similar'
+  | 'alternative_titles'
+  | 'external_ids'
+  | 'translations'
+  | 'watch/providers'
+  | 'aggregate_credits'
+  | 'episode_groups'
+  | 'screened_theatrically'
+  | 'keywords';
+
+export type AppendToResponsePersonKey =
+  | 'images'
+  | 'changes'
+  | 'movie_credits'
+  | 'tv_credits'
+  | 'combined_credits'
+  | 'external_ids'
+  | 'tagged_images'
+  | 'translations';
+
+export type AppendToResponseTvEpisodeKey =
+  | 'images'
+  | 'credits'
+  | 'external_ids'
+  | 'videos'
+  | 'translations';
+
+export type AppendToResponseTvSeasonKey =
+  | 'images'
+  | 'credits'
+  | 'external_ids'
+  | 'videos'
+  | 'aggregate_credits'
+  | 'translations';
+
+type AppendToResponseAllKeys =
+  | AppendToResponseTvKey
+  | AppendToResponseMovieKey
+  | AppendToResponseTvEpisodeKey
+  | AppendToResponseTvSeasonKey
+  | AppendToResponsePersonKey;
+
+export type AppendToResponseMediaType =
+  | 'movie'
+  | 'tvShow'
+  | 'person'
+  | 'tvSeason'
+  | 'tvEpisode';
+
+export type AppendToResponse<
+  K,
+  T extends AppendToResponseAllKeys[] | undefined,
+  Media extends AppendToResponseMediaType
+> = K &
+  (T extends undefined
+    ? object
+    : T extends Array<unknown>
+    ? ('credits' extends T[number]
+        ? {
+            credits: Media extends 'tvEpisode'
+              ? TvEpisodeCredit
+              : Omit<Credits, 'id'>;
+          }
+        : object) &
+        ('videos' extends T[number] ? { videos: Omit<Videos, 'id'> } : object) &
+        ('images' extends T[number]
+          ? {
+              images: Omit<
+                Media extends 'person' ? PeopleImages : Images,
+                'id'
+              >;
+            }
+          : object) &
+        ('recommendations' extends T[number]
+          ? { recommendations: Recommendations }
+          : object) &
+        ('reviews' extends T[number]
+          ? { reviews: Omit<Reviews, 'id'> }
+          : object) &
+        ('reviews' extends T[number]
+          ? { reviews: Omit<Translations, 'id'> }
+          : object) &
+        ('changes' extends T[number]
+          ? {
+              changes: Changes<
+                Media extends 'person'
+                  ? PersonChangeValue
+                  : Media extends 'movie'
+                  ? MovieChangeValue
+                  : Media extends 'tvShow'
+                  ? TvShowChangeValue
+                  : Media extends 'tvSeason'
+                  ? TvSeasonChangeValue
+                  : TvEpisodeChangeValue
+              >;
+            }
+          : object) &
+        ('keywords' extends T[number]
+          ? { keywords: Omit<Keywords, 'id'> }
+          : object) &
+        ('lists' extends T[number]
+          ? { lists: Omit<MovieLists, 'id'> }
+          : object) &
+        ('release_dates' extends T[number]
+          ? { release_dates: Omit<ReleaseDates, 'id'> }
+          : object) &
+        ('alternative_titles' extends T[number]
+          ? { alternative_titles: Omit<AlternativeTitles, 'id'> }
+          : object) &
+        ('external_ids' extends T[number]
+          ? { external_ids: Omit<ExternalIds, 'id'> }
+          : object) &
+        ('translations' extends T[number]
+          ? {
+              translations: Omit<
+                Media extends 'person'
+                  ? PersonTranslations
+                  : Media extends 'tvEpisode'
+                  ? TvEpisodeTranslations
+                  : Translations,
+                'id'
+              >;
+            }
+          : object) &
+        ('watch/providers' extends T[number]
+          ? { 'watch/providers': Omit<WatchProviders, 'id'> }
+          : object) &
+        ('aggregate_credits' extends T[number]
+          ? { aggregate_credits: Omit<Credits, 'id'> }
+          : object) &
+        ('episode_groups' extends T[number]
+          ? { episode_groups: Omit<EpisodeGroups, 'id'> }
+          : object) &
+        ('screened_theatrically' extends T[number]
+          ? { screened_theatrically: Omit<ScreenedTheatrically, 'id'> }
+          : object) &
+        ('similar' extends T[number]
+          ? {
+              similar: Media extends 'movie'
+                ? SimilarMovies
+                : Media extends 'tvShow'
+                ? SimilarTvShows
+                : unknown;
+            }
+          : object) &
+        ('content_ratings' extends T[number]
+          ? { content_ratings: Omit<ContentRatings, 'id'> }
+          : object) &
+        ('movie_credits' extends T[number]
+          ? { movie_credits: Omit<PersonMovieCredit, 'id'> }
+          : object) &
+        ('tv_credits' extends T[number]
+          ? { tv_credits: Omit<PersonTvShowCredit, 'id'> }
+          : object) &
+        ('combined_credits' extends T[number]
+          ? { combined_credits: Omit<PersonCombinedCredits, 'id'> }
+          : object) &
+        ('tagged_images' extends T[number]
+          ? { tagged_images: TaggedImages }
+          : object)
+    : never);

src/types/people.ts

@@ -1,4 +1,4 @@
-import { Movie, Person, TV } from '.';
+import { Image, Movie, Person, TV } from '.';
 
 interface Cast {
   character: string;
@@ -79,7 +79,7 @@ export interface PersonCombinedCredits {
   id: number;
 }
 
-export interface PersonDetail {
+export interface PersonDetails {
   birthday: string;
   known_for_department: string;
   deathday: string;
@@ -96,22 +96,13 @@ export interface PersonDetail {
   homepage: string;
 }
 
-export interface PersonChange {
+export type PersonChangeValue =
-  id: string;
+  | string
-  action: string;
+  | {
-  time: string;
+      profile: {
-  iso_639_1: string;
+        file_path: string;
-  iso_3166_1: string;
+      };
-  value: string | { profile: { file_path: string } };
+    };
-  original_value: string | { profile: { file_path: string } };
-}
-
-export interface PersonChanges {
-  changes: {
-    key: string;
-    items: PersonChange[];
-  }[];
-}
 
 export interface PopularPersons {
   page: number;
@@ -120,6 +111,11 @@ export interface PopularPersons {
   total_pages: number;
 }
 
+export interface PeopleImages {
+  id: number;
+  profiles: Image[];
+}
+
 export interface TaggedImage {
   aspect_ratio: number;
   file_path: string;
@@ -141,7 +137,7 @@ export interface TaggedImages {
   total_pages: number;
 }
 
-export interface PeopleTranslations {
+export interface PersonTranslations {
   id: number;
   translations: {
     iso_3166_1: string;

src/types/review.ts

@@ -1,8 +1,8 @@
 import { Review } from './';
 
-export interface ReviewDetails extends Review{
+export interface ReviewDetails extends Review {
   iso_639_1: string;
   media_id: number;
   media_title: number;
   media_type: number;
-}
+}

src/types/search.ts

@@ -1,3 +1,5 @@
+import { MovieWithMediaType, PersonWithMediaType, TVWithMediaType } from '.';
+
 export interface Search<T> {
   page: number;
   results: T[];
@@ -5,4 +7,7 @@ export interface Search<T> {
   total_results: number;
 }
 
-
+export type MultiSearchResult =
+  | MovieWithMediaType
+  | TVWithMediaType
+  | PersonWithMediaType;

src/types/trending.ts

@@ -1,19 +1,28 @@
-import { Movie, Person, TV } from '.';
+import {
-export type MediaType = 'all' | 'movie' | 'tv' | 'person';
+  Movie,
+  Person,
+  TV,
+  MediaType,
+  MovieWithMediaType,
+  TVWithMediaType,
+  PersonWithMediaType,
+} from '.';
 
 export type TimeWindow = 'day' | 'week';
 
-type TrendingResult<T extends MediaType> = T extends 'tv'
+export type TrendingMediaType = MediaType | 'all';
+
+type TrendingResult<T extends TrendingMediaType> = T extends 'tv'
   ? TV
   : T extends 'movie'
-    ? Movie
+  ? Movie
-    : T extends 'person'
+  : T extends 'person'
-      ? Person
+  ? Person
-      : TV | Movie | Person;
+  : TVWithMediaType | MovieWithMediaType | PersonWithMediaType;
 
-export interface TrendingResults<T extends MediaType> {
+export interface TrendingResults<T extends TrendingMediaType> {
   page: number;
-  results: (TrendingResult<T> & {media_type: MediaType})[];
+  results: TrendingResult<T>[];
   total_pages: number;
   total_results: number;
-}
+}

src/types/tv-episode.ts

@@ -0,0 +1,58 @@
+import { Credits, Crew } from '.';
+
+export interface EpisodeSelection {
+  tvShowID: number;
+  seasonNumber: number;
+  episodeNumber: number;
+}
+
+export interface Episode {
+  air_date: string;
+  episode_number: number;
+  crew: Crew[];
+  guest_stars: GuestStar[];
+  id: number;
+  name: string;
+  overview: string;
+  production_code: string;
+  season_number: number;
+  still_path: string;
+  vote_average: number;
+  vote_count: number;
+  runtime: number;
+  show_id: number;
+}
+
+export interface GuestStar {
+  credit_id: string;
+  order: number;
+  character: string;
+  adult: boolean;
+  gender: number | null;
+  id: number;
+  known_for_department: string;
+  name: string;
+  original_name: string;
+  popularity: number;
+  profile_path: string | null;
+}
+
+export interface TvEpisodeCredit extends Credits {
+  guest_stars: GuestStar[];
+}
+
+export interface TvEpisodeTranslations {
+  id: number;
+  translations: {
+    iso_3166_1: string;
+    iso_639_1: string;
+    name: string;
+    english_name: string;
+    data: {
+      name: string;
+      overview: string;
+    };
+  };
+}
+
+export type TvEpisodeChangeValue = string | unknown;

src/types/tv-seasons.ts

@@ -0,0 +1,23 @@
+import { Episode } from '.';
+
+export interface SeasonSelection {
+  tvShowID: number;
+  seasonNumber: number;
+}
+
+export interface SeasonDetails {
+  air_date: string;
+  episodes: Episode[];
+  name: string;
+  overview: string;
+  id: number;
+  poster_path: string | null;
+  season_number: number;
+}
+
+export type TvSeasonChangeValue =
+  | string
+  | {
+      episode_id: number;
+      episode_number: number;
+    };

src/types/tv-shows.ts

@@ -1,4 +1,10 @@
-import { Genre, ProductionCompany, ProductionCountry, SpokenLanguage, Crew } from './';
+import {
+  Genre,
+  ProductionCompany,
+  ProductionCountry,
+  SpokenLanguage,
+  LanguageOption,
+} from './';
 
 export interface CreatedBy {
   id: number;
@@ -8,6 +14,21 @@ export interface CreatedBy {
   profile_path: string;
 }
 
+export interface NextEpisodeToAir {
+  id: number;
+  name: string;
+  overview: string;
+  vote_average: number;
+  vote_count: number;
+  air_date: string;
+  episode_number: number;
+  production_code: string;
+  runtime: number;
+  season_number: number;
+  show_id: number;
+  still_path: string;
+}
+
 export interface LastEpisodeToAir {
   air_date: string;
   episode_number: number;
@@ -51,7 +72,7 @@ export interface TvShowDetails {
   last_air_date: string;
   last_episode_to_air: LastEpisodeToAir;
   name: string;
-  next_episode_to_air?: any;
+  next_episode_to_air?: NextEpisodeToAir;
   networks: Network[];
   number_of_episodes: number;
   number_of_seasons: number;
@@ -72,66 +93,6 @@ export interface TvShowDetails {
   vote_count: number;
 }
 
-export interface GuestStar {
-  credit_id: string
-  order: number
-  character: string
-  adult: boolean
-  gender: number | null
-  id: number
-  known_for_department: string
-  name: string
-  original_name: string
-  popularity: number
-  profile_path: string | null
-
-}
-
-export interface Episode {
-  air_date: string
-  episode_number: number
-  crew: Crew[]
-  guest_stars: GuestStar[]
-  id: number
-  name: string
-  overview: string
-  production_code: string
-  season_number: number
-  still_path: string
-  vote_average: number
-  vote_count: number
-  show_id: number;
-  runtime: number;
-}
-
-export interface SeasonDetails {
-  air_date: string
-  episodes: Episode[]
-  name: string
-  overview: string
-  id: number
-  poster_path: string | null
-  season_number: number
-}
-
-export interface TvShowItem {
-  id: string;
-  action: string;
-  time: string;
-  value: any;
-  iso_639_1: string;
-  original_value: any;
-}
-
-export interface TvShowChange {
-  key: string;
-  items: TvShowItem[];
-}
-
-export interface TvShowChanges {
-  changes: TvShowChange[];
-}
-
 export interface Network {
   id: number;
   logo_path: string;
@@ -165,7 +126,6 @@ export interface ScreenedTheatrically {
   results: ScreenedTheatricallyResult[];
 }
 
-
 export interface SimilarTvShow {
   backdrop_path: string;
   first_air_date: string;
@@ -190,8 +150,8 @@ export interface SimilarTvShows {
 }
 
 export interface LatestTvShows {
-  backdrop_path?: any;
+  backdrop_path?: string;
-  created_by: any[];
+  created_by: CreatedBy[];
   episode_run_time: number[];
   first_air_date: string;
   genres: Genre[];
@@ -207,10 +167,10 @@ export interface LatestTvShows {
   origin_country: string[];
   original_language: string;
   original_name: string;
-  overview?: any;
+  overview?: string;
   popularity: number;
-  poster_path?: any;
+  poster_path?: string;
-  production_companies: any[];
+  production_companies: ProductionCompany[];
   seasons: Season[];
   status: string;
   type: string;
@@ -218,7 +178,6 @@ export interface LatestTvShows {
   vote_count: number;
 }
 
-
 export interface OnTheAirResult {
   poster_path: string;
   popularity: number;
@@ -242,7 +201,6 @@ export interface OnTheAir {
   total_pages: number;
 }
 
-
 export interface AiringTodayResult {
   poster_path: string;
   popularity: number;
@@ -266,7 +224,6 @@ export interface TvShowsAiringToday {
   total_pages: number;
 }
 
-
 export interface PopularTvShowResult {
   poster_path: string;
   popularity: number;
@@ -290,7 +247,6 @@ export interface PopularTvShows {
   total_pages: number;
 }
 
-
 export interface TopRatedTvShowResult {
   poster_path: string;
   popularity: number;
@@ -314,4 +270,21 @@ export interface TopRatedTvShows {
   total_pages: number;
 }
 
+export interface TvShowChangeValue {
+  season_id: number;
+  season_number: number;
+}
 
+export interface TvShowImageOptions extends LanguageOption {
+  /**
+   * a list of ISO-639-1 values to query
+   */
+  include_image_language?: string[];
+}
+
+export interface TvShowVideoOptions extends LanguageOption {
+  /**
+   * a list of ISO-639-1 values to query
+   */
+  include_video_language?: string[];
+}

src/types/watch-providers.ts

@@ -1,4 +1,3 @@
-
 export interface Flatrate {
   display_priority: number;
   logo_path: string;
@@ -20,7 +19,6 @@ export interface Buy {
   provider_name: string;
 }
 
-
 export interface WatchLocale {
   AR: {
     link: string;
@@ -298,5 +296,3 @@ export interface WatchProviders {
   id: number;
   results: WatchLocale;
 }
-
-

src/utils/getImagePath.ts

@@ -8,7 +8,12 @@
  * @param {string} imagePath raw image path
  * @param {boolean} svg get svg version if true
  */
-export const getFullImagePath = (baseUrl: string, fileSize: string, imagePath: string, svg =  false): string  => {
+export const getFullImagePath = (
+  baseUrl: string,
+  fileSize: string,
+  imagePath: string,
+  svg = false
+): string => {
   const imagePathArr = imagePath.split('.');
   const imageFormat = svg ? 'svg' : imagePathArr[1];
 

src/utils/parseOptions.ts

@@ -1,7 +1,4 @@
-export function parseOptions(
+export function parseOptions(options?: Record<string, any>): string {
-  options?: { [s: string]: any },
+  /* eslint-disable  @typescript-eslint/no-explicit-any */
-): string {
+  return options ? new URLSearchParams(Object.entries(options)).toString() : '';
-  return options
-    ? new URLSearchParams(Object.entries(options)).toString()
-    :  '';
 }

tsconfig.json

@@ -1,28 +1,18 @@
 {
   "compilerOptions": {
-    "target": "es2020" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */,
+    "target": "ES2022" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */,
-    "module": "commonjs" /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */,
+    "module": "CommonJS" /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */,
+    "moduleResolution": "node16",
     "sourceMap": true /* Generates corresponding '.map' file. */,
     "outDir": "dist" /* Redirect output structure to the directory. */,
     "strict": true /* Enable all strict type-checking options. */,
-    "allowSyntheticDefaultImports": true,        /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
     "types": ["node"],
     "esModuleInterop": true /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */,
-    "experimentalDecorators": true /* Enables experimental support for ES7 decorators. */,
-    "emitDecoratorMetadata": true /* Enables experimental support for emitting type metadata for decorators. */,
     "skipLibCheck": true /* Skip type checking of declaration files. */,
-    "forceConsistentCasingInFileNames": true, /* Disallow inconsistently-cased references to the same file. */
+    "forceConsistentCasingInFileNames": true /* Disallow inconsistently-cased references to the same file. */,
-    "typeRoots": [
+    "typeRoots": ["./src/types"]
-      "./src/types"
-    ]
   },
   "types": ["node"],
-  "include": [
+  "include": ["src"],
-    "src"
+  "exclude": ["node_modules", "dist", "./src/types/*.ts"]
-  ],
-  "exclude": [
-    "node_modules",
-    "dist",
-    "./src/types/*.ts"
-  ]
 }