Tmdb Client

https://docs.rs/tmdb_client/1.7.0/
Admin
A Rust client library for interacting with The Movie Database (TMDb) API, providing modules for...
Tokens:232,196
Snippets:724
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Get Movie Changes List - Rust

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/movies_api

Retrieves a list of changes made to a movie's details. It requires the movie ID and can optionally filter by start date, end date, and page number. The function constructs a GET request to the TMDB API.

```Rust
fn get_movie_changes_list(
        &self,
        movie_id: &str,
        start_date: Option<String>,
        end_date: Option<String>,
        page: Option<i32>,
    ) -> Result<crate::models::ChangeDetails, Error> {
        let configuration: &configuration::Configuration = self.configuration.borrow();
        let client = &configuration.client;

        let uri_str = format!(
            "{}/movie/{movie_id}/changes",
            configuration.base_path,
            movie_id = urlencode(movie_id)
        );
        let mut req_builder = client.get(uri_str.as_str());

        if let Some(ref s) = start_date {
            req_builder = req_builder.query(&[("start_date", s)]);
        }
        if let Some(ref s) = end_date {
            req_builder = req_builder.query(&[("end_date", s)]);
        }
        if let Some(ref s) = page {
            req_builder = req_builder.query(&[("page", s)]);
        }
        if let Some(ref apikey) = configuration.api_key {
            req_builder = req_builder.query(&[("api_key", apikey)]);
        }
        if let Some(ref user_agent) = configuration.user_agent {
            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
        }

        // send request
        let req = req_builder.build()?;

        Ok(client.execute(req)?.error_for_status()?.json()?)
    }
```

--------------------------------

### Initialize APIClient with Configuration

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/client

This snippet shows how to create a new APIClient instance by passing a Configuration struct. The client then initializes all its associated API modules (e.g., AccountApi, MoviesApi) using a shared Rc<Configuration>.

```Rust
pub fn new(configuration: Configuration) -> APIClient {
    let rc = Rc::new(configuration);

    APIClient {
        account_api: Box::new(crate::apis::AccountApiClient::new(rc.clone())),
        authentication_api: Box::new(crate::apis::AuthenticationApiClient::new(rc.clone())),
        certifications_api: Box::new(crate::apis::CertificationsApiClient::new(rc.clone())),
        changes_api: Box::new(crate::apis::ChangesApiClient::new(rc.clone())),
        collections_api: Box::new(crate::apis::CollectionsApiClient::new(rc.clone())),
        companies_api: Box::new(crate::apis::CompaniesApiClient::new(rc.clone())),
        configuration_api: Box::new(crate::apis::ConfigurationApiClient::new(rc.clone())),
        credits_api: Box::new(crate::apis::CreditsApiClient::new(rc.clone())),
        discover_api: Box::new(crate::apis::DiscoverApiClient::new(rc.clone())),
        find_api: Box::new(crate::apis::FindApiClient::new(rc.clone())),
        genres_api: Box::new(crate::apis::GenresApiClient::new(rc.clone())),
        guest_sessions_api: Box::new(crate::apis::GuestSessionsApiClient::new(rc.clone())),
        keywords_api: Box::new(crate::apis::KeywordsApiClient::new(rc.clone())),
        lists_api: Box::new(crate::apis::ListsApiClient::new(rc.clone())),
        movies_api: Box::new(crate::apis::MoviesApiClient::new(rc.clone())),
        networks_api: Box::new(crate::apis::NetworksApiClient::new(rc.clone())),
        people_api: Box::new(crate::apis::PeopleApiClient::new(rc.clone())),
        reviews_api: Box::new(crate::apis::ReviewsApiClient::new(rc.clone())),
        search_api: Box::new(crate::apis::SearchApiClient::new(rc.clone())),
        trending_api: Box::new(crate::apis::TrendingApiClient::new(rc.clone())),
        tv_api: Box::new(crate::apis::TVApiClient::new(rc.clone())),
        tv_episodes_api: Box::new(crate::apis::TVEpisodesApiClient::new(rc.clone())),
        tv_seasons_api: Box::new(crate::apis::TVSeasonsApiClient::new(rc.clone())),
    }
}
```

--------------------------------

### Get TV Episode Changes

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/tv_episodes_api

Retrieves the changes made to a TV episode. Requires the episode ID and optionally start date, end date, and page number for pagination.

```Rust
fn get_tv_episode_changes(
        &self,
        episode_id: i32,
        start_date: Option<String>,
        end_date: Option<String>,
        page: Option<i32>,
    ) -> Result<crate::models::ChangeDetails, Error>
```

--------------------------------

### Rustdoc Keyboard Shortcuts

Source: https://docs.rs/tmdb_client/1.7.0/help

This section details keyboard shortcuts for navigating and interacting with Rust documentation generated by rustdoc. It covers actions like showing help, focusing search, navigating results, expanding/collapsing sections, and more.

```text
`?`
    Show this help dialog

`S` / `/`
    Focus the search field

`↑`
    Move up in search results

`↓`
    Move down in search results

`←` / `→`
    Switch result tab (when results focused)

`⏎`
    Go to active search result

`+`
    Expand all sections

`-`
    Collapse all sections

`_`
    Collapse all sections, including impl blocks
```

--------------------------------

### tmdb_client Crate Dependencies

Source: https://docs.rs/tmdb_client/1.7.0/tmdb_client/files/index

Lists the direct dependencies required by the tmdb_client crate. These include libraries for date/time handling, HTTP requests, serialization, and error management.

```Rust
chrono ^0.4
flate2 ^1.0
reqwest ^0.12
serde ^1.0
serde_derive ^1.0
serde_json ^1.0
serde_with ^3.0
thiserror ^2.0
url ^2.5
```

--------------------------------

### Get TV Changes

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/tv_api

Fetches changes made to a TV show's data. Requires the TV ID and allows filtering by start date, end date, and page number.

```rust
fn get_tv_changes(
        &self,
        tv_id: i32,
        start_date: Option<String>,
        end_date: Option<String>,
        page: Option<i32>,
    ) -> Result<crate::models::ChangeDetails, Error>;
```

--------------------------------

### Get TV Season Changes

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/tv_seasons_api

Retrieves the changes made to a TV season. Requires the season ID and optionally accepts start date, end date, and page number for filtering.

```Rust
fn get_tv_season_changes(
    &self,
    season_id: i32,
    start_date: Option<String>,
    end_date: Option<String>,
    page: Option<i32>,
) -> Result<crate::models::ChangeDetails, Error> {
    let configuration: &configuration::Configuration = self.configuration.borrow();
    let client = &configuration.client;

    let uri_str = format!(
        "{}/tv/season/{season_id}/changes",
        configuration.base_path,
        season_id = season_id
    );
    let mut req_builder = client.get(uri_str.as_str());

    if let Some(ref s) = start_date {
        req_builder = req_builder.query(&[("start_date", &s.to_string())]);
    }
    if let Some(ref s) = end_date {
        req_builder = req_builder.query(&[("end_date", &s.to_string())]);
    }
    // The provided snippet is incomplete for the 'page' parameter and API key/user agent headers.
```

--------------------------------

### APIClient Constructor: new

Source: https://docs.rs/tmdb_client/1.7.0/tmdb_client/apis/client/struct

Creates a new APIClient instance with the provided Configuration. This is the primary way to initialize the client.

```Rust
pub fn new(configuration: Configuration) -> APIClient
```

--------------------------------

### Initialize APIClient with API Key

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/client

This function provides a convenient way to initialize the APIClient by accepting an API key as a string. It internally creates a Configuration object and then uses the primary `new` method.

```Rust
pub fn new_with_api_key<T: Into<String>>(api_key: T) -> APIClient {
    let configuration = Configuration::new_with_api_key(api_key);
    APIClient::new(configuration)
}
```

--------------------------------

### Get TV Episode Changes

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/tv_episodes_api

Fetches the change history for a specific TV episode. Supports filtering by start and end dates, pagination, and includes API key and user agent for authentication and identification.

```rust
fn get_tv_episode_changes(
        &self,
        episode_id: i32,
        start_date: Option<String>,
        end_date: Option<String>,
        page: Option<i32>,
    ) -> Result<crate::models::ChangeDetails, Error> {
        let configuration: &configuration::Configuration = self.configuration.borrow();
        let client = &configuration.client;

        let uri_str = format!(
            "{}/tv/episode/{episode_id}/changes",
            configuration.base_path,
            episode_id = episode_id
        );
        let mut req_builder = client.get(uri_str.as_str());

        if let Some(ref s) = start_date {
            req_builder = req_builder.query(&[("start_date", &s.to_string())]);
        }
        if let Some(ref s) = end_date {
            req_builder = req_builder.query(&[("end_date", &s.to_string())]);
        }
        if let Some(ref s) = page {
            req_builder = req_builder.query(&[("page", &s.to_string())]);
        }
        if let Some(ref apikey) = configuration.api_key {
            req_builder = req_builder.query(&[("api_key", apikey)]);
        }
        if let Some(ref user_agent) = configuration.user_agent {
            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
        }

        // send request
        let req = req_builder.build()?;

        Ok(client.execute(req)?.error_for_status()?.json()?)
    }
```

--------------------------------

### DiscoverApiClient Initialization - Rust

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/discover_api

Creates a new instance of the DiscoverApiClient. Requires an Rc<Configuration> to be passed, which holds the base path and HTTP client configuration. This client is used to interact with the TMDB Discover API.

```rust
pub fn new(configuration: Rc<configuration::Configuration>) -> DiscoverApiClient {
        DiscoverApiClient {
            configuration,
        }
    }
```

--------------------------------

### Get TV Show Changes - Rust

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/tv_api

Fetches the change history for a TV show. Supports filtering by start date, end date, and page number. Includes API key and user agent headers.

```Rust
fn get_tv_changes(
        &self,
        tv_id: i32,
        start_date: Option<String>,
        end_date: Option<String>,
        page: Option<i32>,
    ) -> Result<crate::models::ChangeDetails, Error> {
        let configuration: &configuration::Configuration = self.configuration.borrow();
        let client = &configuration.client;

        let uri_str = format!(
            "{}/tv/{tv_id}/changes",
            configuration.base_path,
            tv_id = tv_id
        );
        let mut req_builder = client.get(uri_str.as_str());

        if let Some(ref s) = start_date {
            req_builder = req_builder.query(&[("start_date", &s.to_string())]);
        }
        if let Some(ref s) = end_date {
            req_builder = req_builder.query(&[("end_date", &s.to_string())]);
        }
        if let Some(ref s) = page {
            req_builder = req_builder.query(&[("page", &s.to_string())]);
        }
        if let Some(ref apikey) = configuration.api_key {
            req_builder = req_builder.query(&[("api_key", apikey)]);
        }
        if let Some(ref user_agent) = configuration.user_agent {
            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
        }

        // send request
        let req = req_builder.build()?;

        Ok(client.execute(req)?.error_for_status()?.json()?)
    }
```

--------------------------------

### Create tmdb_client Configuration with API Key

Source: https://docs.rs/tmdb_client/1.7.0/tmdb_client/apis/configuration/struct

Provides a constructor function `new_with_api_key` for the `Configuration` struct. This method allows initializing the client configuration by providing an API key, which is a common requirement for accessing TMDB API functionalities.

```Rust
pub fn new_with_api_key<T: Into<String>>(api_key: T) -> Self
```

--------------------------------

### Get Person Changes

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/people_api

Fetches the change history for a specific person. Supports filtering by date range and pagination. Requires a person ID and optionally accepts language, start date, end date, and page number.

```rust
fn get_person_changes(
        &self,
        person_id: i32,
        language: Option<&str>,
        start_date: Option<String>,
        end_date: Option<String>,
        page: Option<i32>,
    ) -> Result<crate::models::ChangeDetails, Error> {
        let configuration: &configuration::Configuration = self.configuration.borrow();
        let client = &configuration.client;

        let uri_str = format!(
            "{}/person/{person_id}/changes",
            configuration.base_path,
            person_id = person_id
        );
        let mut req_builder = client.get(uri_str.as_str());

        if let Some(ref s) = language {
            req_builder = req_builder.query(&[("language", &s.to_string())]);
        }
        if let Some(ref s) = start_date {
            req_builder = req_builder.query(&[("start_date", &s.to_string())]);
        }
        if let Some(ref s) = end_date {
            req_builder = req_builder.query(&[("end_date", &s.to_string())]);
        }
        if let Some(ref s) = page {
            req_builder = req_builder.query(&[("page", &s.to_string())]);
        }
        if let Some(ref apikey) = configuration.api_key {
            req_builder = req_builder.query(&[("api_key", apikey)]);
        }
        if let Some(ref user_agent) = configuration.user_agent {
            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
        }

        // send request
        let req = req_builder.build()?;

        Ok(client.execute(req)?.error_for_status()?.json()?)
    }
```

--------------------------------

### Initialize TVApiClient

Source: https://docs.rs/tmdb_client/1.7.0/tmdb_client/apis/struct

Creates a new instance of the TVApiClient. This client is used to interact with various TV show-related endpoints of the TMDb API. It requires a configuration object, likely containing API keys and base URLs.

```Rust
pub fn new(configuration: Rc<Configuration>) -> TVApiClient
```

--------------------------------

### Get Paginated Person Changes

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/changes_api

Retrieves a paginated list of person changes from the TMDB API. Supports filtering by start date, end date, and page number. Includes API key and user agent headers.

```Rust
fn get_person_changes_paginated(
        &self,
        start_date: Option<String>,
        end_date: Option<String>,
        page: Option<i32>,
    ) -> Result<crate::models::ChangesPaginated, Error> {
        let configuration: &configuration::Configuration = self.configuration.borrow();
        let client = &configuration.client;

        let uri_str = format!("{}/person/changes", configuration.base_path);
        let mut req_builder = client.get(uri_str.as_str());

        if let Some(ref s) = start_date {
            req_builder = req_builder.query(&[("start_date", &s.to_string())]);
        }
        if let Some(ref s) = end_date {
            req_builder = req_builder.query(&[("end_date", &s.to_string())]);
        }
        if let Some(ref i) = page {
            req_builder = req_builder.query(&[("page", i)]);
        }
        if let Some(ref apikey) = configuration.api_key {
            req_builder = req_builder.query(&[("api_key", apikey)]);
        }
        if let Some(ref user_agent) = configuration.user_agent {
            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
        }

        // send request
        let req = req_builder.build()?;

        Ok(client.execute(req)?.error_for_status()?.json()?) 
    }
```

--------------------------------

### Get Paginated Movie Changes

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/changes_api

Retrieves a paginated list of movie changes from the TMDB API. Supports filtering by start date, end date, and page number. Includes API key and user agent headers.

```Rust
fn get_movie_changes_paginated(
        &self,
        start_date: Option<String>,
        end_date: Option<String>,
        page: Option<i32>,
    ) -> Result<crate::models::ChangesPaginated, Error> {
        let configuration: &configuration::Configuration = self.configuration.borrow();
        let client = &configuration.client;

        let uri_str = format!("{}/movie/changes", configuration.base_path);
        let mut req_builder = client.get(uri_str.as_str());

        if let Some(ref s) = start_date {
            req_builder = req_builder.query(&[("start_date", &s.to_string())]);
        }
        if let Some(ref s) = end_date {
            req_builder = req_builder.query(&[("end_date", &s.to_string())]);
        }
        if let Some(ref i) = page {
            req_builder = req_builder.query(&[("page", i)]);
        }
        if let Some(ref apikey) = configuration.api_key {
            req_builder = req_builder.query(&[("api_key", apikey)]);
        }
        if let Some(ref user_agent) = configuration.user_agent {
            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
        }

        // send request
        let req = req_builder.build()?;

        Ok(client.execute(req)?.error_for_status()?.json()?) 
    }
```

--------------------------------

### TV API Client Initialization

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/tv_api

Initializes the TVApiClient with the provided API configuration. The configuration is wrapped in an `Rc` for shared ownership.

```rust
pub struct TVApiClient {
    configuration: Rc<configuration::Configuration>,
}

pub fn new(configuration: Rc<configuration::Configuration>) -> TVApiClient {
    TVApiClient {
        configuration,
    }
}
```

--------------------------------

### Rust: Create Configuration API Client

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/configuration_api

Initializes a new ConfigurationApiClient with the provided configuration. This client is used to interact with the configuration-related endpoints of the TMDB API.

```Rust
pub fn new(configuration: Rc<configuration::Configuration>) -> ConfigurationApiClient {
        ConfigurationApiClient {
            configuration,
        }
    }
```

--------------------------------

### Get Paginated TV Changes

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/changes_api

Retrieves a paginated list of TV show changes from the TMDB API. Supports filtering by start date, end date, and page number. Includes API key and user agent headers.

```Rust
fn get_tv_changes_paginated(
        &self,
        start_date: Option<String>,
        end_date: Option<String>,
        page: Option<i32>,
    ) -> Result<crate::models::ChangesPaginated, Error> {
        let configuration: &configuration::Configuration = self.configuration.borrow();
        let client = &configuration.client;

        let uri_str = format!("{}/tv/changes", configuration.base_path);
        let mut req_builder = client.get(uri_str.as_str());

        if let Some(ref s) = start_date {
            req_builder = req_builder.query(&[("start_date", &s.to_string())]);
        }
        if let Some(ref s) = end_date {
            req_builder = req_builder.query(&[("end_date", &s.to_string())]);
        }
        if let Some(ref i) = page {
            req_builder = req_builder.query(&[("page", i)]);
        }
        if let Some(ref apikey) = configuration.api_key {
            req_builder = req_builder.query(&[("api_key", apikey)]);
        }
        if let Some(ref user_agent) = configuration.user_agent {
            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
        }

        // send request
        let req = req_builder.build()?;

        Ok(client.execute(req)?.error_for_status()?.json()?) 
    }
```

--------------------------------

### Initialize Movies API Client

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/movies_api

Creates a new instance of the MoviesApiClient. This client is used to make requests to the TMDB Movies API. It requires a configuration object, typically containing API keys and base URLs.

```rust
pub struct MoviesApiClient {
    configuration: Rc<configuration::Configuration>,
}

impl MoviesApiClient {
    pub fn new(configuration: Rc<configuration::Configuration>) -> MoviesApiClient {
        MoviesApiClient {
            configuration,
        }
    }
}
```

--------------------------------

### Get New Authentication Token

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/authentication_api

Gets a request token to be used to validate user's login. This method sends a GET request to the `/authentication/token/new` endpoint.

```rust
    fn get_new_authentication_token(
        &self,
    ) -> Result<crate::models::TokenResponseWithExpiration, Error> {
        let configuration: &configuration::Configuration = self.configuration.borrow();
        let client = &configuration.client;


```

--------------------------------

### Get New Authentication Session

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/authentication_api

Gets a new session ID using a request token. This method sends a GET request to the `/authentication/session/new` endpoint, requiring a `request_token`.

```rust
    fn get_new_authentication_session(
        &self,
        request_token: &str,
    ) -> Result<crate::models::SessionResponse, Error> {
        let configuration: &configuration::Configuration = self.configuration.borrow();
        let client = &configuration.client;

        let uri_str = format!("{}/authentication/session/new", configuration.base_path);
        let mut req_builder = client.get(uri_str.as_str());

        req_builder = req_builder.query(&[("request_token", &request_token.to_string())]);
        if let Some(ref apikey) = configuration.api_key {
            req_builder = req_builder.query(&[("api_key", apikey)]);
        }
        if let Some(ref user_agent) = configuration.user_agent {
            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
        }

        // send request
        let req = req_builder.build()?;

        Ok(client.execute(req)?.error_for_status()?.json()?)
    }

```

--------------------------------

### TV Episodes API Client Initialization

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/tv_episodes_api

Initializes the TVEpisodesApiClient with the provided configuration. This client is used to make requests to the TMDB API for TV episode data.

```Rust
pub struct TVEpisodesApiClient {
    configuration: Rc<configuration::Configuration>,
}

impl TVEpisodesApiClient {
    pub fn new(configuration: Rc<configuration::Configuration>) -> TVEpisodesApiClient {
        TVEpisodesApiClient {
            configuration,
        }
    }
}
```

--------------------------------

### Get New Authentication Guest Session

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/authentication_api

Gets a guest session ID. This is useful for users who don't want to sign up. This method sends a GET request to the `/authentication/guest_session/new` endpoint.

```rust
    fn get_new_authentication_guest_session(
        &self,
    ) -> Result<crate::models::GuestSessionResponse, Error> {
        let configuration: &configuration::Configuration = self.configuration.borrow();
        let client = &configuration.client;

        let uri_str = format!(
            "{}/authentication/guest_session/new",
            configuration.base_path
        );
        let mut req_builder = client.get(uri_str.as_str());

        if let Some(ref apikey) = configuration.api_key {
            req_builder = req_builder.query(&[("api_key", apikey)]);
        }
        if let Some(ref user_agent) = configuration.user_agent {
            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
        }

        // send request
        let req = req_builder.build()?;

        Ok(client.execute(req)?.error_for_status()?.json()?)
    }

```

--------------------------------

### Configuration API Client

Source: https://docs.rs/tmdb_client/1.7.0/tmdb_client/apis/client/index

Defines the ConfigurationApiClient struct for retrieving TMDb API configuration details, such as image base URLs and supported countries.

```Rust
struct ConfigurationApiClient
```

--------------------------------

### Configuration API Client in tmdb_client

Source: https://docs.rs/tmdb_client/1.7.0/tmdb_client/apis/configuration/index

Offers the API client for retrieving general configuration settings from The Movie Database. This struct is part of the apis module.

```Rust
struct ConfigurationApiClient
```

--------------------------------

### Get Type ID

Source: https://docs.rs/tmdb_client/1.7.0/tmdb_client/apis/struct

Gets the `TypeId` of `self`. This is a blanket implementation for any type `T`.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### APIClient Constructor: new_from_env

Source: https://docs.rs/tmdb_client/1.7.0/tmdb_client/apis/client/struct

Creates a new APIClient instance by reading the API key from environment variables. Assumes the API key is available in the environment.

```Rust
pub fn new_from_env() -> APIClient
```

--------------------------------

### Rust: Get TMDB Languages List

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/configuration_api

Fetches a list of languages supported by the TMDB API. This function makes a GET request with authentication and user agent details. The result is a vector of `Translation` models.

```Rust
fn get_languages_list(&self) -> Result<Vec<crate::models::Translation>, Error> {
        let configuration: &configuration::Configuration = self.configuration.borrow();
        let client = &configuration.client;

        let uri_str = format!("{}/configuration/languages", configuration.base_path);
        let mut req_builder = client.get(uri_str.as_str());

        if let Some(ref apikey) = configuration.api_key {
            req_builder = req_builder.query(&[("api_key", apikey)]);
        }
        if let Some(ref user_agent) = configuration.user_agent {
            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
        }

        // send request
        let req = req_builder.build()?;

        Ok(client.execute(req)?.error_for_status()?.json()?)
    }
```

--------------------------------

### Initialize APIClient from Environment Variable

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/client

This method initializes the APIClient by reading the TMDB API key from the 'TMDB_API_KEY' environment variable. It expects the variable to be set and will panic if it's missing.

```Rust
pub fn new_from_env() -> APIClient {
    let api_key = env::var("TMDB_API_KEY").expect("Missing TMDB_API_KEY env var");
    APIClient::new_with_api_key(api_key)
}
```

--------------------------------

### Rust: Get TMDB Jobs List

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/configuration_api

Fetches a list of jobs available in the TMDB API. This function sends a GET request with the API key and user agent. The result is a vector of `Jobs` models.

```Rust
fn get_jobs_list(&self) -> Result<Vec<crate::models::Jobs>, Error> {
        let configuration: &configuration::Configuration = self.configuration.borrow();
        let client = &configuration.client;

        let uri_str = format!("{}/configuration/jobs", configuration.base_path);
        let mut req_builder = client.get(uri_str.as_str());

        if let Some(ref apikey) = configuration.api_key {
            req_builder = req_builder.query(&[("api_key", apikey)]);
        }
        if let Some(ref user_agent) = configuration.user_agent {
            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
        }

        // send request
        let req = req_builder.build()?;

        Ok(client.execute(req)?.error_for_status()?.json()?)
    }
```

--------------------------------

### Rust tmdb_client Crate Structure

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/guest_sessions_api

This snippet outlines the file structure of the tmdb_client Rust crate. It includes the main library file (lib.rs), API modules, export files, and model definitions.

```Rust
tmdb_client
apis
account_api.rs
authentication_api.rs
certifications_api.rs
changes_api.rs
client.rs
collections_api.rs
companies_api.rs
configuration.rs
configuration_api.rs
credits_api.rs
discover_api.rs
find_api.rs
genres_api.rs
guest_sessions_api.rs
keywords_api.rs
lists_api.rs
mod.rs
movies_api.rs
networks_api.rs
people_api.rs
reviews_api.rs
search_api.rs
trending_api.rs
tv_api.rs
tv_episode_groups_api.rs
tv_episodes_api.rs
tv_seasons_api.rs
files
exports.rs
mod.rs
models.rs
models
access_token_body.rs
account_details.rs
account_states.rs
accountdetails_avatar.rs
accountdetails_avatar_gravatar.rs
alternative_names_list.rs
alternativenameslist_results.rs
alternativenameslist_item.rs
cast.rs
cast_details.rs
certification.rs
certifications.rs
certifications_certifications.rs
change_details.rs
changedetails_changes.rs
changedetails_items.rs
changes_object.rs
changes_paginated.rs
collection_object.rs
collection_paginated.rs
collection_part.rs
company_details.rs
company_object.rs
company_paginated.rs
configuration.rs
configuration_images.rs
creator.rs
credit.rs
credit_media.rs
credit_media_seasons.rs
credit_person.rs
credits.rs
crew.rs
crew_details.rs
episode_details.rs
episode_group_details.rs
episode_group_group.rs
episode_group_list.rs
episode_group_object.rs
episode_rating_list.rs
episoderatinglist_rated.rs
episoderatinglist_results.rs
external_ids.rs
find_by_external_id_results.rs
genre.rs
genres_list.rs
guest_session_response.rs
guest_star.rs
image.rs
images.rs
item_status.rs
jobs.rs
keyword.rs
keyword_paginated.rs
keywords_list.rs
list_body.rs
list_details.rs
list_object.rs
list_status_response.rs
lists_paginated.rs
media_favorite_body.rs
media_id_body.rs
media_type.rs
media_watchlist_body.rs
mod.rs
movie_alternative_titles_list.rs
movie_details.rs
movie_object.rs
movie_paginated.rs
movieobject_dates.rs
network.rs
person_credits.rs
person_details.rs
person_object.rs
person_paginated.rs
person_tagged_images_paginated.rs
ratings_list.rs
ratingslist_results.rs
release_date.rs
release_dates_list.rs
releasedateslist_results.rs
review.rs
review_object.rs
reviews_paginated.rs
search_multi_results_paginated.rs
season_details.rs
season_episode_ids.rs
season_episode_list.rs
season_object.rs
ssession_response.rs
status_code_message.rs
success_response.rs
tagged_image.rs
time_window.rs
timezones.rs
token_response.rs
token_response_with_expiration.rs
translation.rs
translation_data.rs
translations_list.rs
tv_alternative_titles_list.rs
tv_details.rs
tv_episode_object.rs
tv_episodes_paginated.rs
tv_object.rs
tv_paginated.rs
value_body.rs
video.rs
videos_list.rs
lib.rs
```

--------------------------------

### Get Movie Alternative Titles List - Rust

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/movies_api

Fetches a list of alternative titles for a given movie. It requires the movie ID and can optionally filter by country. The function constructs a GET request to the TMDB API.

```Rust
fn get_movie_alternative_titles_list(
        &self,
        movie_id: i32,
        country: Option<&str>,
    ) -> Result<crate::models::MovieAlternativeTitlesList, Error> {
        let configuration: &configuration::Configuration = self.configuration.borrow();
        let client = &configuration.client;

        let uri_str = format!(
            "{}/movie/{movie_id}/alternative_titles",
            configuration.base_path,
            movie_id = movie_id
        );
        let mut req_builder = client.get(uri_str.as_str());

        if let Some(ref s) = country {
            req_builder = req_builder.query(&[("country", &s.to_string())]);
        }
        if let Some(ref apikey) = configuration.api_key {
            req_builder = req_builder.query(&[("api_key", apikey)]);
        }
        if let Some(ref user_agent) = configuration.user_agent {
            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
        }

        // send request
        let req = req_builder.build()?;

        Ok(client.execute(req)?.error_for_status()?.json()?)
    }
```

--------------------------------

### Rust: Get TMDB Configuration

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/configuration_api

Fetches the general configuration settings for the TMDB API. It supports an optional API key and includes the user agent in the request headers. The response is deserialized into a `Configuration` model.

```Rust
fn get_configuration(
        &self,
        api_key: Option<&str>,
    ) -> Result<crate::models::Configuration, Error> {
        let configuration: &configuration::Configuration = self.configuration.borrow();
        let client = &configuration.client;

        let uri_str = format!("{}/configuration", configuration.base_path);
        let mut req_builder = client.get(uri_str.as_str());

        if let Some(ref s) = api_key {
            req_builder = req_builder.query(&[("api_key", &s.to_string())]);
        }
        if let Some(ref apikey) = configuration.api_key {
            req_builder = req_builder.query(&[("api_key", apikey)]);
        }
        if let Some(ref user_agent) = configuration.user_agent {
            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
        }

        // send request
        let req = req_builder.build()?;

        Ok(client.execute(req)?.error_for_status()?.json()?)
    }
```

--------------------------------

### Get Person Combined Credits

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/people_api

Fetches the combined movie and TV credits for a specific person from the TMDB API. It constructs a GET request, optionally including language, API key, and user agent headers.

```rust
fn get_person_combined_credits(
        &self,
        person_id: i32,
        language: Option<&str>
    ) -> Result<crate::models::CombinedCredits, Error> {
        let configuration: &configuration::Configuration = self.configuration.borrow();
        let client = &configuration.client;

        let uri_str = format!(
            "{{}}/person/{{person_id}}/combined_credits",
            configuration.base_path,
            person_id = person_id
        );
        let mut req_builder = client.get(uri_str.as_str());

        if let Some(ref s) = language {
            req_builder = req_builder.query(&[("language", &s.to_string())]);
        }
        if let Some(ref apikey) = configuration.api_key {
            req_builder = req_builder.query(&[("api_key", apikey)]);
        }
        if let Some(ref user_agent) = configuration.user_agent {
            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
        }

        // send request
        let req = req_builder.build()?;

        Ok(client.execute(req)?.error_for_status()?.json()?)
    }
```

--------------------------------

### tmdb_client Supported Platforms

Source: https://docs.rs/tmdb_client/1.7.0/tmdb_client/files/index

Details the platforms for which the tmdb_client crate has been built and tested. This indicates cross-platform compatibility.

```Rust
i686-pc-windows-msvc
x86_64-apple-darwin
x86_64-pc-windows-msvc
x86_64-unknown-linux-gnu
```

--------------------------------

### Get TV Keywords List - Rust

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/tv_api

Retrieves a list of keywords associated with a TV show ID. This Rust function constructs a GET request, including API key and user agent, and returns the keywords as a `KeywordsList`.

```Rust
fn get_tv_keywords_list(&self, tv_id: i32) -> Result<crate::models::KeywordsList, Error> {
    let configuration: &configuration::Configuration = self.configuration.borrow();
    let client = &configuration.client;

    let uri_str = format!(
        "{}/tv/{tv_id}/keywords",
        configuration.base_path,
        tv_id = tv_id
    );
    let mut req_builder = client.get(uri_str.as_str());

    if let Some(ref apikey) = configuration.api_key {
        req_builder = req_builder.query(&[("api_key", apikey)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }

    // send request
    let req = req_builder.build()?;

    Ok(client.execute(req)?.error_for_status()?.json()?)
}
```

--------------------------------

### Get TV Images - Rust

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/tv_api

Fetches images associated with a TV show ID, supporting language and image language filtering. The function prepares a GET request with necessary parameters and returns the images in an `Images` model.

```Rust
fn get_tv_images(
    &self,
    tv_id: i32,
    language: Option<&str>,
    include_image_language: Option<&str>,
) -> Result<crate::models::Images, Error> {
    let configuration: &configuration::Configuration = self.configuration.borrow();
    let client = &configuration.client;

    let uri_str = format!(
        "{}/tv/{tv_id}/images",
        configuration.base_path,
        tv_id = tv_id
    );
    let mut req_builder = client.get(uri_str.as_str());

    if let Some(ref s) = language {
        req_builder = req_builder.query(&[("language", &s.to_string())]);
    }
    if let Some(ref s) = include_image_language {
        req_builder = req_builder.query(&[("include_image_language", &s.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        req_builder = req_builder.query(&[("api_key", apikey)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }

    // send request
    let req = req_builder.build()?;

    Ok(client.execute(req)?.error_for_status()?.json()?)
}
```

--------------------------------

### Create Genres API Client in Rust

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/genres_api

This code creates a `GenresApiClient` struct with a `new` method that takes a configuration as input. The configuration includes the base path for the API and the reqwest client.

```Rust
pub struct GenresApiClient {
    configuration: Rc<configuration::Configuration>,
}

impl GenresApiClient {
    pub fn new(configuration: Rc<configuration::Configuration>) -> GenresApiClient {
        GenresApiClient {
            configuration,
        }
    }
}
```

--------------------------------

### Rust API Configuration Setup

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/configuration

Defines the Configuration struct for the TMDB client API, allowing customization of the base path, user agent, and API key. It utilizes the reqwest library for HTTP requests.

```Rust
use reqwest;

pub struct Configuration {
    pub base_path: String,
    pub user_agent: Option<String>,
    pub client: reqwest::blocking::Client,
    pub api_key: Option<String>,
}

impl Configuration {
    pub fn new() -> Configuration {
        Configuration::default()
    }

    pub fn new_with_api_key<T: Into<String>>(api_key: T) -> Self {
        let mut result = Configuration::default();
        result.api_key = Some(api_key.into());
        result
    }
}

impl Default for Configuration {
    fn default() -> Self {
        Configuration {
            base_path: "https://api.themoviedb.org/3".to_owned(),
            user_agent: Some("OpenAPI-Generator/3/rust".to_owned()),
            client: reqwest::blocking::Client::new(),
            api_key: None,
        }
    }
}
```

--------------------------------

### Get Popular Persons Paginated - Rust

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/people_api

Fetches a paginated list of popular persons from the TMDB API. This function supports filtering by language and specifying the page number. It constructs a GET request to '/person/popular' and returns a PersonPaginated model.

```rust
fn get_person_popular_paginated(
        &self,
        language: Option<&str>,
        page: Option<i32>,
    ) -> Result<crate::models::PersonPaginated, Error> {
        let configuration: &configuration::Configuration = self.configuration.borrow();
        let client = &configuration.client;

        let uri_str = format!("{}/person/popular", configuration.base_path);
        let mut req_builder = client.get(uri_str.as_str());

        if let Some(ref s) = language {
            req_builder = req_builder.query(&[("language", &s.to_string())]);
        }
        if let Some(ref s) = page {
            req_builder = req_builder.query(&[("page", &s.to_string())]);
        }
        if let Some(ref apikey) = configuration.api_key {
            req_builder = req_builder.query(&[("api_key", apikey)]);
        }
        if let Some(ref user_agent) = configuration.user_agent {
            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
        }

        // send request
        let req = req_builder.build()?;

        Ok(client.execute(req)?.error_for_status()?.json()?)
    }
```

--------------------------------

### Rust tmdb_client Crate Structure

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/configuration_api

This snippet outlines the file structure of the tmdb_client Rust crate. It includes the main library file (lib.rs), API modules, export files, and model definitions.

```Rust
tmdb_client
apis
account_api.rs
authentication_api.rs
certifications_api.rs
changes_api.rs
client.rs
collections_api.rs
companies_api.rs
configuration.rs
configuration_api.rs
credits_api.rs
discover_api.rs
find_api.rs
genres_api.rs
guest_sessions_api.rs
keywords_api.rs
lists_api.rs
mod.rs
movies_api.rs
networks_api.rs
people_api.rs
reviews_api.rs
search_api.rs
trending_api.rs
tv_api.rs
tv_episode_groups_api.rs
tv_episodes_api.rs
tv_seasons_api.rs
files
exports.rs
mod.rs
models.rs
models
access_token_body.rs
account_details.rs
account_states.rs
accountdetails_avatar.rs
accountdetails_avatar_gravatar.rs
alternative_names_list.rs
alternativenameslist_results.rs
alternativenameslist_item.rs
cast.rs
cast_details.rs
certification.rs
certifications.rs
certifications_certifications.rs
change_details.rs
changedetails_changes.rs
changedetails_items.rs
changes_object.rs
changes_paginated.rs
collection_object.rs
collection_paginated.rs
collection_part.rs
company_details.rs
company_object.rs
company_paginated.rs
configuration.rs
configuration_images.rs
creator.rs
credit.rs
credit_media.rs
credit_media_seasons.rs
credit_person.rs
credits.rs
crew.rs
crew_details.rs
episode_details.rs
episode_group_details.rs
episode_group_group.rs
episode_group_list.rs
episode_group_object.rs
episode_rating_list.rs
episoderatinglist_rated.rs
episoderatinglist_results.rs
external_ids.rs
find_by_external_id_results.rs
genre.rs
genres_list.rs
guest_session_response.rs
guest_star.rs
image.rs
images.rs
item_status.rs
jobs.rs
keyword.rs
keyword_paginated.rs
keywords_list.rs
list_body.rs
list_details.rs
list_object.rs
list_status_response.rs
lists_paginated.rs
media_favorite_body.rs
media_id_body.rs
media_type.rs
media_watchlist_body.rs
mod.rs
movie_alternative_titles_list.rs
movie_details.rs
movie_object.rs
movie_paginated.rs
movieobject_dates.rs
network.rs
person_credits.rs
person_details.rs
person_object.rs
person_paginated.rs
person_tagged_images_paginated.rs
ratings_list.rs
ratingslist_results.rs
release_date.rs
release_dates_list.rs
releasedateslist_results.rs
review.rs
review_object.rs
reviews_paginated.rs
search_multi_results_paginated.rs
season_details.rs
season_episode_ids.rs
season_episode_list.rs
season_object.rs
ssession_response.rs
status_code_message.rs
success_response.rs
tagged_image.rs
time_window.rs
timezones.rs
token_response.rs
token_response_with_expiration.rs
translation.rs
translation_data.rs
translations_list.rs
tv_alternative_titles_list.rs
tv_details.rs
tv_episode_object.rs
tv_episodes_paginated.rs
tv_object.rs
tv_paginated.rs
value_body.rs
video.rs
videos_list.rs
lib.rs
```

--------------------------------

### Get Movie Certifications List (Rust)

Source: https://docs.rs/tmdb_client/1.7.0/src/tmdb_client/apis/certifications_api

Fetches a list of movie certifications from the TMDB API. It constructs the request using the provided configuration, including the base path, API key, and user agent, and then sends the GET request.

```Rust
impl CertificationsApi for CertificationsApiClient {
    fn get_movie_certifications_list(&self) -> Result<crate::models::Certifications, Error> {
        let configuration: &configuration::Configuration = self.configuration.borrow();
        let client = &configuration.client;

        let uri_str = format!("{}/certification/movie/list", configuration.base_path);
        let mut req_builder = client.get(uri_str.as_str());

        if let Some(ref apikey) = configuration.api_key {
            req_builder = req_builder.query(&[("api_key", apikey)]);
        }
        if let Some(ref user_agent) = configuration.user_agent {
            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
        }

        // send request
        let req = req_builder.build()?;

        Ok(client.execute(req)?.error_for_status()?.json()?)
    }

```
Tokens:
Raw