diff --git a/.github/workflows/publish-pypi.yml b/.github/workflows/publish-pypi.yml
new file mode 100644
index 0000000..2af8ae3
--- /dev/null
+++ b/.github/workflows/publish-pypi.yml
@@ -0,0 +1,31 @@
+# This workflow is triggered when a GitHub release is created.
+# It can also be run manually to re-publish to PyPI in case it failed for some reason.
+# You can run this workflow by navigating to https://www.github.com/jed-richards/tmdb-client-python/actions/workflows/publish-pypi.yml
+name: Publish PyPI
+on:
+  workflow_dispatch:
+
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    name: publish
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Rye
+        run: |
+          curl -sSf https://rye.astral.sh/get | bash
+          echo "$HOME/.rye/shims" >> $GITHUB_PATH
+        env:
+          RYE_VERSION: '0.35.0'
+          RYE_INSTALL_OPTION: '--yes'
+
+      - name: Publish to PyPI
+        run: |
+          bash ./bin/publish-pypi
+        env:
+          PYPI_TOKEN: ${{ secrets.TMDB_CLIENT_PYPI_TOKEN || secrets.PYPI_TOKEN }}
diff --git a/.github/workflows/release-doctor.yml b/.github/workflows/release-doctor.yml
new file mode 100644
index 0000000..5fc951c
--- /dev/null
+++ b/.github/workflows/release-doctor.yml
@@ -0,0 +1,21 @@
+name: Release Doctor
+on:
+  pull_request:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  release_doctor:
+    name: release doctor
+    runs-on: ubuntu-latest
+    if: github.repository == 'jed-richards/tmdb-client-python' && (github.event_name == 'push' || github.event_name == 'workflow_dispatch' || startsWith(github.head_ref, 'release-please') || github.head_ref == 'next')
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Check release environment
+        run: |
+          bash ./bin/check-release-environment
+        env:
+          PYPI_TOKEN: ${{ secrets.TMDB_CLIENT_PYPI_TOKEN || secrets.PYPI_TOKEN }}
diff --git a/.release-please-manifest.json b/.release-please-manifest.json
new file mode 100644
index 0000000..55f722d
--- /dev/null
+++ b/.release-please-manifest.json
@@ -0,0 +1,3 @@
+{
+  ".": "0.0.1-alpha.1"
+}
\ No newline at end of file
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..e3e124f
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,31 @@
+# Changelog
+
+## 0.0.1-alpha.1 (2025-01-09)
+
+Full Changelog: [v0.0.1-alpha.0...v0.0.1-alpha.1](https://github.com/jed-richards/tmdb-client-python/compare/v0.0.1-alpha.0...v0.0.1-alpha.1)
+
+### Bug Fixes
+
+* **client:** only call .close() when needed ([#14](https://github.com/jed-richards/tmdb-client-python/issues/14)) ([03ff396](https://github.com/jed-richards/tmdb-client-python/commit/03ff396a1a3ed1aff8ddec6558c16b61c7a0a7c5))
+
+
+### Chores
+
+* add missing isclass check ([#12](https://github.com/jed-richards/tmdb-client-python/issues/12)) ([bf22165](https://github.com/jed-richards/tmdb-client-python/commit/bf2216509089b73a5a830e0c0393a0b0e694c27d))
+* go live ([#1](https://github.com/jed-richards/tmdb-client-python/issues/1)) ([52d09bc](https://github.com/jed-richards/tmdb-client-python/commit/52d09bcc58858516926e87291888cd7876f30528))
+* **internal:** add support for TypeAliasType ([#7](https://github.com/jed-richards/tmdb-client-python/issues/7)) ([a2431e4](https://github.com/jed-richards/tmdb-client-python/commit/a2431e4606b1297233cf838e4abf312e757edde8))
+* **internal:** bump httpx dependency ([#13](https://github.com/jed-richards/tmdb-client-python/issues/13)) ([d9c9a06](https://github.com/jed-richards/tmdb-client-python/commit/d9c9a06ead15699f26276bfc5d8183e4ab72a22e))
+* **internal:** bump pydantic dependency ([#4](https://github.com/jed-richards/tmdb-client-python/issues/4)) ([f003528](https://github.com/jed-richards/tmdb-client-python/commit/f0035285be67634d4e311df2cf3b798fd58d1a91))
+* **internal:** bump pyright ([#6](https://github.com/jed-richards/tmdb-client-python/issues/6)) ([c9a92ad](https://github.com/jed-richards/tmdb-client-python/commit/c9a92ada7b47a1511dc4b0350709aadf41240745))
+* **internal:** codegen related update ([#11](https://github.com/jed-richards/tmdb-client-python/issues/11)) ([741ad29](https://github.com/jed-richards/tmdb-client-python/commit/741ad292ca22a50b74b902b84b2e70e18a8dbf51))
+* **internal:** codegen related update ([#16](https://github.com/jed-richards/tmdb-client-python/issues/16)) ([c4702b5](https://github.com/jed-richards/tmdb-client-python/commit/c4702b53299800eb15141b699eeb82a098782a95))
+* **internal:** codegen related update ([#8](https://github.com/jed-richards/tmdb-client-python/issues/8)) ([9ccc77a](https://github.com/jed-richards/tmdb-client-python/commit/9ccc77a8ba80f8b141d24793f55b2b27124a21d0))
+* **internal:** codegen related update ([#9](https://github.com/jed-richards/tmdb-client-python/issues/9)) ([01084c7](https://github.com/jed-richards/tmdb-client-python/commit/01084c7c7ae65525a21c1168d45a9da98809bc64))
+* **internal:** fix some typos ([#10](https://github.com/jed-richards/tmdb-client-python/issues/10)) ([6fef57c](https://github.com/jed-richards/tmdb-client-python/commit/6fef57c3ac4687a3a912b1706ee608e73f0b3437))
+* make the `Omit` type public ([#3](https://github.com/jed-richards/tmdb-client-python/issues/3)) ([910225b](https://github.com/jed-richards/tmdb-client-python/commit/910225bbb05dc000e96c966a00255d30ad5679a2))
+
+
+### Documentation
+
+* fix typos ([#15](https://github.com/jed-richards/tmdb-client-python/issues/15)) ([53cbcfb](https://github.com/jed-richards/tmdb-client-python/commit/53cbcfb1873ad9596e6bcb6c250a54d95e3c7865))
+* **readme:** fix http client proxies example ([#5](https://github.com/jed-richards/tmdb-client-python/issues/5)) ([05b8868](https://github.com/jed-richards/tmdb-client-python/commit/05b886849209ea96594aaf8daab2ec65d5ba45ec))
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 493de80..c9062e6 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -63,7 +63,7 @@ If you’d like to use the repository from source, you can either install from g
 To install via git:
 
 ```sh
-$ pip install git+ssh://git@github.com/stainless-sdks/tmdb-client-python.git
+$ pip install git+ssh://git@github.com/jed-richards/tmdb-client-python.git
 ```
 
 Alternatively, you can build from source and install the wheel file:
@@ -121,7 +121,7 @@ the changes aren't made through the automated pipeline, you may want to make rel
 
 ### Publish with a GitHub workflow
 
-You can release to package managers by using [the `Publish PyPI` GitHub action](https://www.github.com/stainless-sdks/tmdb-client-python/actions/workflows/publish-pypi.yml). This requires a setup organization or repository secret to be set up.
+You can release to package managers by using [the `Publish PyPI` GitHub action](https://www.github.com/jed-richards/tmdb-client-python/actions/workflows/publish-pypi.yml). This requires a setup organization or repository secret to be set up.
 
 ### Publish manually
 
diff --git a/LICENSE b/LICENSE
index cd37dd7..1bdb2c0 100644
--- a/LICENSE
+++ b/LICENSE
@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2024 Tmdb Client
+   Copyright 2025 Tmdb Client
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
diff --git a/README.md b/README.md
index 1023ae8..c151523 100644
--- a/README.md
+++ b/README.md
@@ -15,8 +15,8 @@ The REST API documentation can be found on [docs.tmdb-client.com](https://docs.t
 ## Installation
 
 ```sh
-# install from this staging repo
-pip install git+ssh://git@github.com/stainless-sdks/tmdb-client-python.git
+# install from the production repo
+pip install git+ssh://git@github.com/jed-richards/tmdb-client-python.git
 ```
 
 > [!NOTE]
@@ -104,7 +104,7 @@ except tmdb_client.APIStatusError as e:
     print(e.response)
 ```
 
-Error codes are as followed:
+Error codes are as follows:
 
 | Status Code | Error Type                 |
 | ----------- | -------------------------- |
@@ -206,9 +206,9 @@ latest = response.parse()  # get the object that `movies.latest.retrieve()` woul
 print(latest.id)
 ```
 
-These methods return an [`APIResponse`](https://github.com/stainless-sdks/tmdb-client-python/tree/main/src/tmdb_client/_response.py) object.
+These methods return an [`APIResponse`](https://github.com/jed-richards/tmdb-client-python/tree/main/src/tmdb_client/_response.py) object.
 
-The async client returns an [`AsyncAPIResponse`](https://github.com/stainless-sdks/tmdb-client-python/tree/main/src/tmdb_client/_response.py) with the same structure, the only difference being `await`able methods for reading the response content.
+The async client returns an [`AsyncAPIResponse`](https://github.com/jed-richards/tmdb-client-python/tree/main/src/tmdb_client/_response.py) with the same structure, the only difference being `await`able methods for reading the response content.
 
 #### `.with_streaming_response`
 
@@ -235,8 +235,7 @@ If you need to access undocumented endpoints, params, or response properties, th
 #### Undocumented endpoints
 
 To make requests to undocumented endpoints, you can make requests using `client.get`, `client.post`, and other
-http verbs. Options on the client will be respected (such as retries) will be respected when making this
-request.
+http verbs. Options on the client will be respected (such as retries) when making this request.
 
 ```py
 import httpx
@@ -265,18 +264,19 @@ can also get all the extra fields on the Pydantic model as a dict with
 
 You can directly override the [httpx client](https://www.python-httpx.org/api/#client) to customize it for your use case, including:
 
-- Support for proxies
-- Custom transports
+- Support for [proxies](https://www.python-httpx.org/advanced/proxies/)
+- Custom [transports](https://www.python-httpx.org/advanced/transports/)
 - Additional [advanced](https://www.python-httpx.org/advanced/clients/) functionality
 
 ```python
+import httpx
 from tmdb_client import TmdbClient, DefaultHttpxClient
 
 client = TmdbClient(
     # Or use the `TMDB_CLIENT_BASE_URL` env var
     base_url="http://my.test.server.example.com:8083",
     http_client=DefaultHttpxClient(
-        proxies="http://my.test.proxy.example.com",
+        proxy="http://my.test.proxy.example.com",
         transport=httpx.HTTPTransport(local_address="0.0.0.0"),
     ),
 )
@@ -292,17 +292,27 @@ client.with_options(http_client=DefaultHttpxClient(...))
 
 By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting.
 
+```py
+from tmdb_client import TmdbClient
+
+with TmdbClient() as client:
+  # make requests here
+  ...
+
+# HTTP client is now closed
+```
+
 ## Versioning
 
 This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:
 
 1. Changes that only affect static types, without breaking runtime behavior.
-2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals)_.
+2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals.)_
 3. Changes that we do not expect to impact the vast majority of users in practice.
 
 We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.
 
-We are keen for your feedback; please open an [issue](https://www.github.com/stainless-sdks/tmdb-client-python/issues) with questions, bugs, or suggestions.
+We are keen for your feedback; please open an [issue](https://www.github.com/jed-richards/tmdb-client-python/issues) with questions, bugs, or suggestions.
 
 ### Determining the installed version
 
diff --git a/bin/check-release-environment b/bin/check-release-environment
new file mode 100644
index 0000000..7d1a2f7
--- /dev/null
+++ b/bin/check-release-environment
@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+
+errors=()
+
+if [ -z "${PYPI_TOKEN}" ]; then
+  errors+=("The TMDB_CLIENT_PYPI_TOKEN secret has not been set. Please set it in either this repository's secrets or your organization secrets.")
+fi
+
+lenErrors=${#errors[@]}
+
+if [[ lenErrors -gt 0 ]]; then
+  echo -e "Found the following errors in the release environment:\n"
+
+  for error in "${errors[@]}"; do
+    echo -e "- $error\n"
+  done
+
+  exit 1
+fi
+
+echo "The environment is ready to push releases!"
diff --git a/pyproject.toml b/pyproject.toml
index fb261e0..4771361 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "tmdb_client"
-version = "0.0.1-alpha.0"
+version = "0.0.1-alpha.1"
 description = "The official Python library for the tmdb-client API"
 dynamic = ["readme"]
 license = "Apache-2.0"
@@ -10,7 +10,7 @@ authors = [
 dependencies = [
     "httpx>=0.23.0, <1",
     "pydantic>=1.9.0, <3",
-    "typing-extensions>=4.7, <5",
+    "typing-extensions>=4.10, <5",
     "anyio>=3.5.0, <5",
     "distro>=1.7.0, <2",
     "sniffio",
@@ -34,8 +34,8 @@ classifiers = [
 ]
 
 [project.urls]
-Homepage = "https://github.com/stainless-sdks/tmdb-client-python"
-Repository = "https://github.com/stainless-sdks/tmdb-client-python"
+Homepage = "https://github.com/jed-richards/tmdb-client-python"
+Repository = "https://github.com/jed-richards/tmdb-client-python"
 
 
 
@@ -54,7 +54,7 @@ dev-dependencies = [
     "dirty-equals>=0.6.0",
     "importlib-metadata>=6.7.0",
     "rich>=13.7.1",
-    "nest_asyncio==1.6.0"
+    "nest_asyncio==1.6.0",
 ]
 
 [tool.rye.scripts]
@@ -122,7 +122,7 @@ path = "README.md"
 [[tool.hatch.metadata.hooks.fancy-pypi-readme.substitutions]]
 # replace relative links with absolute links
 pattern = '\[(.+?)\]\(((?!https?://)\S+?)\)'
-replacement = '[\1](https://github.com/stainless-sdks/tmdb-client-python/tree/main/\g<2>)'
+replacement = '[\1](https://github.com/jed-richards/tmdb-client-python/tree/main/\g<2>)'
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
diff --git a/release-please-config.json b/release-please-config.json
new file mode 100644
index 0000000..daad7a3
--- /dev/null
+++ b/release-please-config.json
@@ -0,0 +1,66 @@
+{
+  "packages": {
+    ".": {}
+  },
+  "$schema": "https://raw.githubusercontent.com/stainless-api/release-please/main/schemas/config.json",
+  "include-v-in-tag": true,
+  "include-component-in-tag": false,
+  "versioning": "prerelease",
+  "prerelease": true,
+  "bump-minor-pre-major": true,
+  "bump-patch-for-minor-pre-major": false,
+  "pull-request-header": "Automated Release PR",
+  "pull-request-title-pattern": "release: ${version}",
+  "changelog-sections": [
+    {
+      "type": "feat",
+      "section": "Features"
+    },
+    {
+      "type": "fix",
+      "section": "Bug Fixes"
+    },
+    {
+      "type": "perf",
+      "section": "Performance Improvements"
+    },
+    {
+      "type": "revert",
+      "section": "Reverts"
+    },
+    {
+      "type": "chore",
+      "section": "Chores"
+    },
+    {
+      "type": "docs",
+      "section": "Documentation"
+    },
+    {
+      "type": "style",
+      "section": "Styles"
+    },
+    {
+      "type": "refactor",
+      "section": "Refactors"
+    },
+    {
+      "type": "test",
+      "section": "Tests",
+      "hidden": true
+    },
+    {
+      "type": "build",
+      "section": "Build System"
+    },
+    {
+      "type": "ci",
+      "section": "Continuous Integration",
+      "hidden": true
+    }
+  ],
+  "release-type": "python",
+  "extra-files": [
+    "src/tmdb_client/_version.py"
+  ]
+}
\ No newline at end of file
diff --git a/requirements-dev.lock b/requirements-dev.lock
index a38336b..3280756 100644
--- a/requirements-dev.lock
+++ b/requirements-dev.lock
@@ -35,7 +35,7 @@ h11==0.14.0
     # via httpcore
 httpcore==1.0.2
     # via httpx
-httpx==0.25.2
+httpx==0.28.1
     # via respx
     # via tmdb-client
 idna==3.4
@@ -62,13 +62,13 @@ platformdirs==3.11.0
     # via virtualenv
 pluggy==1.5.0
     # via pytest
-pydantic==2.9.2
+pydantic==2.10.3
     # via tmdb-client
-pydantic-core==2.23.4
+pydantic-core==2.27.1
     # via pydantic
 pygments==2.18.0
     # via rich
-pyright==1.1.389
+pyright==1.1.390
 pytest==8.3.3
     # via pytest-asyncio
 pytest-asyncio==0.24.0
@@ -76,7 +76,7 @@ python-dateutil==2.8.2
     # via time-machine
 pytz==2023.3.post1
     # via dirty-equals
-respx==0.20.2
+respx==0.22.0
 rich==13.7.1
 ruff==0.6.9
 setuptools==68.2.2
@@ -85,7 +85,6 @@ six==1.16.0
     # via python-dateutil
 sniffio==1.3.0
     # via anyio
-    # via httpx
     # via tmdb-client
 time-machine==2.9.0
 tomli==2.0.2
diff --git a/requirements.lock b/requirements.lock
index 01bc838..2907c38 100644
--- a/requirements.lock
+++ b/requirements.lock
@@ -25,18 +25,17 @@ h11==0.14.0
     # via httpcore
 httpcore==1.0.2
     # via httpx
-httpx==0.25.2
+httpx==0.28.1
     # via tmdb-client
 idna==3.4
     # via anyio
     # via httpx
-pydantic==2.9.2
+pydantic==2.10.3
     # via tmdb-client
-pydantic-core==2.23.4
+pydantic-core==2.27.1
     # via pydantic
 sniffio==1.3.0
     # via anyio
-    # via httpx
     # via tmdb-client
 typing-extensions==4.12.2
     # via anyio
diff --git a/src/tmdb_client/__init__.py b/src/tmdb_client/__init__.py
index 3471473..38b5e6a 100644
--- a/src/tmdb_client/__init__.py
+++ b/src/tmdb_client/__init__.py
@@ -1,7 +1,7 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 from . import types
-from ._types import NOT_GIVEN, NoneType, NotGiven, Transport, ProxiesTypes
+from ._types import NOT_GIVEN, Omit, NoneType, NotGiven, Transport, ProxiesTypes
 from ._utils import file_from_path
 from ._client import (
     Client,
@@ -46,6 +46,7 @@
     "ProxiesTypes",
     "NotGiven",
     "NOT_GIVEN",
+    "Omit",
     "TmdbClientError",
     "APIError",
     "APIStatusError",
diff --git a/src/tmdb_client/_base_client.py b/src/tmdb_client/_base_client.py
index 876fce2..043c468 100644
--- a/src/tmdb_client/_base_client.py
+++ b/src/tmdb_client/_base_client.py
@@ -767,6 +767,9 @@ def __init__(self, **kwargs: Any) -> None:
 
 class SyncHttpxClientWrapper(DefaultHttpxClient):
     def __del__(self) -> None:
+        if self.is_closed:
+            return
+
         try:
             self.close()
         except Exception:
@@ -1334,6 +1337,9 @@ def __init__(self, **kwargs: Any) -> None:
 
 class AsyncHttpxClientWrapper(DefaultAsyncHttpxClient):
     def __del__(self) -> None:
+        if self.is_closed:
+            return
+
         try:
             # TODO(someday): support non asyncio runtimes here
             asyncio.get_running_loop().create_task(self.aclose())
diff --git a/src/tmdb_client/_client.py b/src/tmdb_client/_client.py
index 7c0076b..cde0039 100644
--- a/src/tmdb_client/_client.py
+++ b/src/tmdb_client/_client.py
@@ -8,7 +8,7 @@
 
 import httpx
 
-from . import resources, _exceptions
+from . import _exceptions
 from ._qs import Querystring
 from ._types import (
     NOT_GIVEN,
@@ -24,6 +24,20 @@
     get_async_library,
 )
 from ._version import __version__
+from .resources import (
+    find,
+    lists,
+    search,
+    credits,
+    reviews,
+    episodes,
+    trending,
+    tv_series,
+    discover_tv,
+    trending_movies,
+    trending_people,
+    trending_tv_shows,
+)
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import APIStatusError, TmdbClientError
 from ._base_client import (
@@ -31,13 +45,28 @@
     SyncAPIClient,
     AsyncAPIClient,
 )
+from .resources.tv import tv
+from .resources.genres import genres
+from .resources.movies import movies
+from .resources.people import people
+from .resources.person import person
+from .resources.accounts import accounts
+from .resources.keywords import keywords
+from .resources.networks import networks
+from .resources.tv_shows import tv_shows
+from .resources.companies import companies
+from .resources.collections import collections
+from .resources.configuration import configuration
+from .resources.authentication import authentication
+from .resources.certifications import certifications
+from .resources.guest_sessions import guest_sessions
+from .resources.watch_providers import watch_providers
 
 __all__ = [
     "Timeout",
     "Transport",
     "ProxiesTypes",
     "RequestOptions",
-    "resources",
     "TmdbClient",
     "AsyncTmdbClient",
     "Client",
@@ -46,34 +75,34 @@
 
 
 class TmdbClient(SyncAPIClient):
-    movies: resources.MoviesResource
-    tv: resources.TvResource
-    search: resources.SearchResource
-    people: resources.PeopleResource
-    configuration: resources.ConfigurationResource
-    discover_tv: resources.DiscoverTvResource
-    trending: resources.TrendingResource
-    trending_movies: resources.TrendingMoviesResource
-    trending_tv_shows: resources.TrendingTvShowsResource
-    episodes: resources.EpisodesResource
-    trending_people: resources.TrendingPeopleResource
-    authentication: resources.AuthenticationResource
-    find: resources.FindResource
-    tv_shows: resources.TvShowsResource
-    accounts: resources.AccountsResource
-    certifications: resources.CertificationsResource
-    collections: resources.CollectionsResource
-    companies: resources.CompaniesResource
-    credits: resources.CreditsResource
-    genres: resources.GenresResource
-    guest_sessions: resources.GuestSessionsResource
-    watch_providers: resources.WatchProvidersResource
-    keywords: resources.KeywordsResource
-    lists: resources.ListsResource
-    networks: resources.NetworksResource
-    reviews: resources.ReviewsResource
-    person: resources.PersonResource
-    tv_series: resources.TvSeriesResource
+    movies: movies.MoviesResource
+    tv: tv.TvResource
+    search: search.SearchResource
+    people: people.PeopleResource
+    configuration: configuration.ConfigurationResource
+    discover_tv: discover_tv.DiscoverTvResource
+    trending: trending.TrendingResource
+    trending_movies: trending_movies.TrendingMoviesResource
+    trending_tv_shows: trending_tv_shows.TrendingTvShowsResource
+    episodes: episodes.EpisodesResource
+    trending_people: trending_people.TrendingPeopleResource
+    authentication: authentication.AuthenticationResource
+    find: find.FindResource
+    tv_shows: tv_shows.TvShowsResource
+    accounts: accounts.AccountsResource
+    certifications: certifications.CertificationsResource
+    collections: collections.CollectionsResource
+    companies: companies.CompaniesResource
+    credits: credits.CreditsResource
+    genres: genres.GenresResource
+    guest_sessions: guest_sessions.GuestSessionsResource
+    watch_providers: watch_providers.WatchProvidersResource
+    keywords: keywords.KeywordsResource
+    lists: lists.ListsResource
+    networks: networks.NetworksResource
+    reviews: reviews.ReviewsResource
+    person: person.PersonResource
+    tv_series: tv_series.TvSeriesResource
     with_raw_response: TmdbClientWithRawResponse
     with_streaming_response: TmdbClientWithStreamedResponse
 
@@ -131,34 +160,34 @@ def __init__(
             _strict_response_validation=_strict_response_validation,
         )
 
-        self.movies = resources.MoviesResource(self)
-        self.tv = resources.TvResource(self)
-        self.search = resources.SearchResource(self)
-        self.people = resources.PeopleResource(self)
-        self.configuration = resources.ConfigurationResource(self)
-        self.discover_tv = resources.DiscoverTvResource(self)
-        self.trending = resources.TrendingResource(self)
-        self.trending_movies = resources.TrendingMoviesResource(self)
-        self.trending_tv_shows = resources.TrendingTvShowsResource(self)
-        self.episodes = resources.EpisodesResource(self)
-        self.trending_people = resources.TrendingPeopleResource(self)
-        self.authentication = resources.AuthenticationResource(self)
-        self.find = resources.FindResource(self)
-        self.tv_shows = resources.TvShowsResource(self)
-        self.accounts = resources.AccountsResource(self)
-        self.certifications = resources.CertificationsResource(self)
-        self.collections = resources.CollectionsResource(self)
-        self.companies = resources.CompaniesResource(self)
-        self.credits = resources.CreditsResource(self)
-        self.genres = resources.GenresResource(self)
-        self.guest_sessions = resources.GuestSessionsResource(self)
-        self.watch_providers = resources.WatchProvidersResource(self)
-        self.keywords = resources.KeywordsResource(self)
-        self.lists = resources.ListsResource(self)
-        self.networks = resources.NetworksResource(self)
-        self.reviews = resources.ReviewsResource(self)
-        self.person = resources.PersonResource(self)
-        self.tv_series = resources.TvSeriesResource(self)
+        self.movies = movies.MoviesResource(self)
+        self.tv = tv.TvResource(self)
+        self.search = search.SearchResource(self)
+        self.people = people.PeopleResource(self)
+        self.configuration = configuration.ConfigurationResource(self)
+        self.discover_tv = discover_tv.DiscoverTvResource(self)
+        self.trending = trending.TrendingResource(self)
+        self.trending_movies = trending_movies.TrendingMoviesResource(self)
+        self.trending_tv_shows = trending_tv_shows.TrendingTvShowsResource(self)
+        self.episodes = episodes.EpisodesResource(self)
+        self.trending_people = trending_people.TrendingPeopleResource(self)
+        self.authentication = authentication.AuthenticationResource(self)
+        self.find = find.FindResource(self)
+        self.tv_shows = tv_shows.TvShowsResource(self)
+        self.accounts = accounts.AccountsResource(self)
+        self.certifications = certifications.CertificationsResource(self)
+        self.collections = collections.CollectionsResource(self)
+        self.companies = companies.CompaniesResource(self)
+        self.credits = credits.CreditsResource(self)
+        self.genres = genres.GenresResource(self)
+        self.guest_sessions = guest_sessions.GuestSessionsResource(self)
+        self.watch_providers = watch_providers.WatchProvidersResource(self)
+        self.keywords = keywords.KeywordsResource(self)
+        self.lists = lists.ListsResource(self)
+        self.networks = networks.NetworksResource(self)
+        self.reviews = reviews.ReviewsResource(self)
+        self.person = person.PersonResource(self)
+        self.tv_series = tv_series.TvSeriesResource(self)
         self.with_raw_response = TmdbClientWithRawResponse(self)
         self.with_streaming_response = TmdbClientWithStreamedResponse(self)
 
@@ -268,34 +297,34 @@ def _make_status_error(
 
 
 class AsyncTmdbClient(AsyncAPIClient):
-    movies: resources.AsyncMoviesResource
-    tv: resources.AsyncTvResource
-    search: resources.AsyncSearchResource
-    people: resources.AsyncPeopleResource
-    configuration: resources.AsyncConfigurationResource
-    discover_tv: resources.AsyncDiscoverTvResource
-    trending: resources.AsyncTrendingResource
-    trending_movies: resources.AsyncTrendingMoviesResource
-    trending_tv_shows: resources.AsyncTrendingTvShowsResource
-    episodes: resources.AsyncEpisodesResource
-    trending_people: resources.AsyncTrendingPeopleResource
-    authentication: resources.AsyncAuthenticationResource
-    find: resources.AsyncFindResource
-    tv_shows: resources.AsyncTvShowsResource
-    accounts: resources.AsyncAccountsResource
-    certifications: resources.AsyncCertificationsResource
-    collections: resources.AsyncCollectionsResource
-    companies: resources.AsyncCompaniesResource
-    credits: resources.AsyncCreditsResource
-    genres: resources.AsyncGenresResource
-    guest_sessions: resources.AsyncGuestSessionsResource
-    watch_providers: resources.AsyncWatchProvidersResource
-    keywords: resources.AsyncKeywordsResource
-    lists: resources.AsyncListsResource
-    networks: resources.AsyncNetworksResource
-    reviews: resources.AsyncReviewsResource
-    person: resources.AsyncPersonResource
-    tv_series: resources.AsyncTvSeriesResource
+    movies: movies.AsyncMoviesResource
+    tv: tv.AsyncTvResource
+    search: search.AsyncSearchResource
+    people: people.AsyncPeopleResource
+    configuration: configuration.AsyncConfigurationResource
+    discover_tv: discover_tv.AsyncDiscoverTvResource
+    trending: trending.AsyncTrendingResource
+    trending_movies: trending_movies.AsyncTrendingMoviesResource
+    trending_tv_shows: trending_tv_shows.AsyncTrendingTvShowsResource
+    episodes: episodes.AsyncEpisodesResource
+    trending_people: trending_people.AsyncTrendingPeopleResource
+    authentication: authentication.AsyncAuthenticationResource
+    find: find.AsyncFindResource
+    tv_shows: tv_shows.AsyncTvShowsResource
+    accounts: accounts.AsyncAccountsResource
+    certifications: certifications.AsyncCertificationsResource
+    collections: collections.AsyncCollectionsResource
+    companies: companies.AsyncCompaniesResource
+    credits: credits.AsyncCreditsResource
+    genres: genres.AsyncGenresResource
+    guest_sessions: guest_sessions.AsyncGuestSessionsResource
+    watch_providers: watch_providers.AsyncWatchProvidersResource
+    keywords: keywords.AsyncKeywordsResource
+    lists: lists.AsyncListsResource
+    networks: networks.AsyncNetworksResource
+    reviews: reviews.AsyncReviewsResource
+    person: person.AsyncPersonResource
+    tv_series: tv_series.AsyncTvSeriesResource
     with_raw_response: AsyncTmdbClientWithRawResponse
     with_streaming_response: AsyncTmdbClientWithStreamedResponse
 
@@ -353,34 +382,34 @@ def __init__(
             _strict_response_validation=_strict_response_validation,
         )
 
-        self.movies = resources.AsyncMoviesResource(self)
-        self.tv = resources.AsyncTvResource(self)
-        self.search = resources.AsyncSearchResource(self)
-        self.people = resources.AsyncPeopleResource(self)
-        self.configuration = resources.AsyncConfigurationResource(self)
-        self.discover_tv = resources.AsyncDiscoverTvResource(self)
-        self.trending = resources.AsyncTrendingResource(self)
-        self.trending_movies = resources.AsyncTrendingMoviesResource(self)
-        self.trending_tv_shows = resources.AsyncTrendingTvShowsResource(self)
-        self.episodes = resources.AsyncEpisodesResource(self)
-        self.trending_people = resources.AsyncTrendingPeopleResource(self)
-        self.authentication = resources.AsyncAuthenticationResource(self)
-        self.find = resources.AsyncFindResource(self)
-        self.tv_shows = resources.AsyncTvShowsResource(self)
-        self.accounts = resources.AsyncAccountsResource(self)
-        self.certifications = resources.AsyncCertificationsResource(self)
-        self.collections = resources.AsyncCollectionsResource(self)
-        self.companies = resources.AsyncCompaniesResource(self)
-        self.credits = resources.AsyncCreditsResource(self)
-        self.genres = resources.AsyncGenresResource(self)
-        self.guest_sessions = resources.AsyncGuestSessionsResource(self)
-        self.watch_providers = resources.AsyncWatchProvidersResource(self)
-        self.keywords = resources.AsyncKeywordsResource(self)
-        self.lists = resources.AsyncListsResource(self)
-        self.networks = resources.AsyncNetworksResource(self)
-        self.reviews = resources.AsyncReviewsResource(self)
-        self.person = resources.AsyncPersonResource(self)
-        self.tv_series = resources.AsyncTvSeriesResource(self)
+        self.movies = movies.AsyncMoviesResource(self)
+        self.tv = tv.AsyncTvResource(self)
+        self.search = search.AsyncSearchResource(self)
+        self.people = people.AsyncPeopleResource(self)
+        self.configuration = configuration.AsyncConfigurationResource(self)
+        self.discover_tv = discover_tv.AsyncDiscoverTvResource(self)
+        self.trending = trending.AsyncTrendingResource(self)
+        self.trending_movies = trending_movies.AsyncTrendingMoviesResource(self)
+        self.trending_tv_shows = trending_tv_shows.AsyncTrendingTvShowsResource(self)
+        self.episodes = episodes.AsyncEpisodesResource(self)
+        self.trending_people = trending_people.AsyncTrendingPeopleResource(self)
+        self.authentication = authentication.AsyncAuthenticationResource(self)
+        self.find = find.AsyncFindResource(self)
+        self.tv_shows = tv_shows.AsyncTvShowsResource(self)
+        self.accounts = accounts.AsyncAccountsResource(self)
+        self.certifications = certifications.AsyncCertificationsResource(self)
+        self.collections = collections.AsyncCollectionsResource(self)
+        self.companies = companies.AsyncCompaniesResource(self)
+        self.credits = credits.AsyncCreditsResource(self)
+        self.genres = genres.AsyncGenresResource(self)
+        self.guest_sessions = guest_sessions.AsyncGuestSessionsResource(self)
+        self.watch_providers = watch_providers.AsyncWatchProvidersResource(self)
+        self.keywords = keywords.AsyncKeywordsResource(self)
+        self.lists = lists.AsyncListsResource(self)
+        self.networks = networks.AsyncNetworksResource(self)
+        self.reviews = reviews.AsyncReviewsResource(self)
+        self.person = person.AsyncPersonResource(self)
+        self.tv_series = tv_series.AsyncTvSeriesResource(self)
         self.with_raw_response = AsyncTmdbClientWithRawResponse(self)
         self.with_streaming_response = AsyncTmdbClientWithStreamedResponse(self)
 
@@ -491,130 +520,134 @@ def _make_status_error(
 
 class TmdbClientWithRawResponse:
     def __init__(self, client: TmdbClient) -> None:
-        self.movies = resources.MoviesResourceWithRawResponse(client.movies)
-        self.tv = resources.TvResourceWithRawResponse(client.tv)
-        self.search = resources.SearchResourceWithRawResponse(client.search)
-        self.people = resources.PeopleResourceWithRawResponse(client.people)
-        self.configuration = resources.ConfigurationResourceWithRawResponse(client.configuration)
-        self.discover_tv = resources.DiscoverTvResourceWithRawResponse(client.discover_tv)
-        self.trending = resources.TrendingResourceWithRawResponse(client.trending)
-        self.trending_movies = resources.TrendingMoviesResourceWithRawResponse(client.trending_movies)
-        self.trending_tv_shows = resources.TrendingTvShowsResourceWithRawResponse(client.trending_tv_shows)
-        self.episodes = resources.EpisodesResourceWithRawResponse(client.episodes)
-        self.trending_people = resources.TrendingPeopleResourceWithRawResponse(client.trending_people)
-        self.authentication = resources.AuthenticationResourceWithRawResponse(client.authentication)
-        self.find = resources.FindResourceWithRawResponse(client.find)
-        self.tv_shows = resources.TvShowsResourceWithRawResponse(client.tv_shows)
-        self.accounts = resources.AccountsResourceWithRawResponse(client.accounts)
-        self.certifications = resources.CertificationsResourceWithRawResponse(client.certifications)
-        self.collections = resources.CollectionsResourceWithRawResponse(client.collections)
-        self.companies = resources.CompaniesResourceWithRawResponse(client.companies)
-        self.credits = resources.CreditsResourceWithRawResponse(client.credits)
-        self.genres = resources.GenresResourceWithRawResponse(client.genres)
-        self.guest_sessions = resources.GuestSessionsResourceWithRawResponse(client.guest_sessions)
-        self.watch_providers = resources.WatchProvidersResourceWithRawResponse(client.watch_providers)
-        self.keywords = resources.KeywordsResourceWithRawResponse(client.keywords)
-        self.lists = resources.ListsResourceWithRawResponse(client.lists)
-        self.networks = resources.NetworksResourceWithRawResponse(client.networks)
-        self.reviews = resources.ReviewsResourceWithRawResponse(client.reviews)
-        self.person = resources.PersonResourceWithRawResponse(client.person)
-        self.tv_series = resources.TvSeriesResourceWithRawResponse(client.tv_series)
+        self.movies = movies.MoviesResourceWithRawResponse(client.movies)
+        self.tv = tv.TvResourceWithRawResponse(client.tv)
+        self.search = search.SearchResourceWithRawResponse(client.search)
+        self.people = people.PeopleResourceWithRawResponse(client.people)
+        self.configuration = configuration.ConfigurationResourceWithRawResponse(client.configuration)
+        self.discover_tv = discover_tv.DiscoverTvResourceWithRawResponse(client.discover_tv)
+        self.trending = trending.TrendingResourceWithRawResponse(client.trending)
+        self.trending_movies = trending_movies.TrendingMoviesResourceWithRawResponse(client.trending_movies)
+        self.trending_tv_shows = trending_tv_shows.TrendingTvShowsResourceWithRawResponse(client.trending_tv_shows)
+        self.episodes = episodes.EpisodesResourceWithRawResponse(client.episodes)
+        self.trending_people = trending_people.TrendingPeopleResourceWithRawResponse(client.trending_people)
+        self.authentication = authentication.AuthenticationResourceWithRawResponse(client.authentication)
+        self.find = find.FindResourceWithRawResponse(client.find)
+        self.tv_shows = tv_shows.TvShowsResourceWithRawResponse(client.tv_shows)
+        self.accounts = accounts.AccountsResourceWithRawResponse(client.accounts)
+        self.certifications = certifications.CertificationsResourceWithRawResponse(client.certifications)
+        self.collections = collections.CollectionsResourceWithRawResponse(client.collections)
+        self.companies = companies.CompaniesResourceWithRawResponse(client.companies)
+        self.credits = credits.CreditsResourceWithRawResponse(client.credits)
+        self.genres = genres.GenresResourceWithRawResponse(client.genres)
+        self.guest_sessions = guest_sessions.GuestSessionsResourceWithRawResponse(client.guest_sessions)
+        self.watch_providers = watch_providers.WatchProvidersResourceWithRawResponse(client.watch_providers)
+        self.keywords = keywords.KeywordsResourceWithRawResponse(client.keywords)
+        self.lists = lists.ListsResourceWithRawResponse(client.lists)
+        self.networks = networks.NetworksResourceWithRawResponse(client.networks)
+        self.reviews = reviews.ReviewsResourceWithRawResponse(client.reviews)
+        self.person = person.PersonResourceWithRawResponse(client.person)
+        self.tv_series = tv_series.TvSeriesResourceWithRawResponse(client.tv_series)
 
 
 class AsyncTmdbClientWithRawResponse:
     def __init__(self, client: AsyncTmdbClient) -> None:
-        self.movies = resources.AsyncMoviesResourceWithRawResponse(client.movies)
-        self.tv = resources.AsyncTvResourceWithRawResponse(client.tv)
-        self.search = resources.AsyncSearchResourceWithRawResponse(client.search)
-        self.people = resources.AsyncPeopleResourceWithRawResponse(client.people)
-        self.configuration = resources.AsyncConfigurationResourceWithRawResponse(client.configuration)
-        self.discover_tv = resources.AsyncDiscoverTvResourceWithRawResponse(client.discover_tv)
-        self.trending = resources.AsyncTrendingResourceWithRawResponse(client.trending)
-        self.trending_movies = resources.AsyncTrendingMoviesResourceWithRawResponse(client.trending_movies)
-        self.trending_tv_shows = resources.AsyncTrendingTvShowsResourceWithRawResponse(client.trending_tv_shows)
-        self.episodes = resources.AsyncEpisodesResourceWithRawResponse(client.episodes)
-        self.trending_people = resources.AsyncTrendingPeopleResourceWithRawResponse(client.trending_people)
-        self.authentication = resources.AsyncAuthenticationResourceWithRawResponse(client.authentication)
-        self.find = resources.AsyncFindResourceWithRawResponse(client.find)
-        self.tv_shows = resources.AsyncTvShowsResourceWithRawResponse(client.tv_shows)
-        self.accounts = resources.AsyncAccountsResourceWithRawResponse(client.accounts)
-        self.certifications = resources.AsyncCertificationsResourceWithRawResponse(client.certifications)
-        self.collections = resources.AsyncCollectionsResourceWithRawResponse(client.collections)
-        self.companies = resources.AsyncCompaniesResourceWithRawResponse(client.companies)
-        self.credits = resources.AsyncCreditsResourceWithRawResponse(client.credits)
-        self.genres = resources.AsyncGenresResourceWithRawResponse(client.genres)
-        self.guest_sessions = resources.AsyncGuestSessionsResourceWithRawResponse(client.guest_sessions)
-        self.watch_providers = resources.AsyncWatchProvidersResourceWithRawResponse(client.watch_providers)
-        self.keywords = resources.AsyncKeywordsResourceWithRawResponse(client.keywords)
-        self.lists = resources.AsyncListsResourceWithRawResponse(client.lists)
-        self.networks = resources.AsyncNetworksResourceWithRawResponse(client.networks)
-        self.reviews = resources.AsyncReviewsResourceWithRawResponse(client.reviews)
-        self.person = resources.AsyncPersonResourceWithRawResponse(client.person)
-        self.tv_series = resources.AsyncTvSeriesResourceWithRawResponse(client.tv_series)
+        self.movies = movies.AsyncMoviesResourceWithRawResponse(client.movies)
+        self.tv = tv.AsyncTvResourceWithRawResponse(client.tv)
+        self.search = search.AsyncSearchResourceWithRawResponse(client.search)
+        self.people = people.AsyncPeopleResourceWithRawResponse(client.people)
+        self.configuration = configuration.AsyncConfigurationResourceWithRawResponse(client.configuration)
+        self.discover_tv = discover_tv.AsyncDiscoverTvResourceWithRawResponse(client.discover_tv)
+        self.trending = trending.AsyncTrendingResourceWithRawResponse(client.trending)
+        self.trending_movies = trending_movies.AsyncTrendingMoviesResourceWithRawResponse(client.trending_movies)
+        self.trending_tv_shows = trending_tv_shows.AsyncTrendingTvShowsResourceWithRawResponse(client.trending_tv_shows)
+        self.episodes = episodes.AsyncEpisodesResourceWithRawResponse(client.episodes)
+        self.trending_people = trending_people.AsyncTrendingPeopleResourceWithRawResponse(client.trending_people)
+        self.authentication = authentication.AsyncAuthenticationResourceWithRawResponse(client.authentication)
+        self.find = find.AsyncFindResourceWithRawResponse(client.find)
+        self.tv_shows = tv_shows.AsyncTvShowsResourceWithRawResponse(client.tv_shows)
+        self.accounts = accounts.AsyncAccountsResourceWithRawResponse(client.accounts)
+        self.certifications = certifications.AsyncCertificationsResourceWithRawResponse(client.certifications)
+        self.collections = collections.AsyncCollectionsResourceWithRawResponse(client.collections)
+        self.companies = companies.AsyncCompaniesResourceWithRawResponse(client.companies)
+        self.credits = credits.AsyncCreditsResourceWithRawResponse(client.credits)
+        self.genres = genres.AsyncGenresResourceWithRawResponse(client.genres)
+        self.guest_sessions = guest_sessions.AsyncGuestSessionsResourceWithRawResponse(client.guest_sessions)
+        self.watch_providers = watch_providers.AsyncWatchProvidersResourceWithRawResponse(client.watch_providers)
+        self.keywords = keywords.AsyncKeywordsResourceWithRawResponse(client.keywords)
+        self.lists = lists.AsyncListsResourceWithRawResponse(client.lists)
+        self.networks = networks.AsyncNetworksResourceWithRawResponse(client.networks)
+        self.reviews = reviews.AsyncReviewsResourceWithRawResponse(client.reviews)
+        self.person = person.AsyncPersonResourceWithRawResponse(client.person)
+        self.tv_series = tv_series.AsyncTvSeriesResourceWithRawResponse(client.tv_series)
 
 
 class TmdbClientWithStreamedResponse:
     def __init__(self, client: TmdbClient) -> None:
-        self.movies = resources.MoviesResourceWithStreamingResponse(client.movies)
-        self.tv = resources.TvResourceWithStreamingResponse(client.tv)
-        self.search = resources.SearchResourceWithStreamingResponse(client.search)
-        self.people = resources.PeopleResourceWithStreamingResponse(client.people)
-        self.configuration = resources.ConfigurationResourceWithStreamingResponse(client.configuration)
-        self.discover_tv = resources.DiscoverTvResourceWithStreamingResponse(client.discover_tv)
-        self.trending = resources.TrendingResourceWithStreamingResponse(client.trending)
-        self.trending_movies = resources.TrendingMoviesResourceWithStreamingResponse(client.trending_movies)
-        self.trending_tv_shows = resources.TrendingTvShowsResourceWithStreamingResponse(client.trending_tv_shows)
-        self.episodes = resources.EpisodesResourceWithStreamingResponse(client.episodes)
-        self.trending_people = resources.TrendingPeopleResourceWithStreamingResponse(client.trending_people)
-        self.authentication = resources.AuthenticationResourceWithStreamingResponse(client.authentication)
-        self.find = resources.FindResourceWithStreamingResponse(client.find)
-        self.tv_shows = resources.TvShowsResourceWithStreamingResponse(client.tv_shows)
-        self.accounts = resources.AccountsResourceWithStreamingResponse(client.accounts)
-        self.certifications = resources.CertificationsResourceWithStreamingResponse(client.certifications)
-        self.collections = resources.CollectionsResourceWithStreamingResponse(client.collections)
-        self.companies = resources.CompaniesResourceWithStreamingResponse(client.companies)
-        self.credits = resources.CreditsResourceWithStreamingResponse(client.credits)
-        self.genres = resources.GenresResourceWithStreamingResponse(client.genres)
-        self.guest_sessions = resources.GuestSessionsResourceWithStreamingResponse(client.guest_sessions)
-        self.watch_providers = resources.WatchProvidersResourceWithStreamingResponse(client.watch_providers)
-        self.keywords = resources.KeywordsResourceWithStreamingResponse(client.keywords)
-        self.lists = resources.ListsResourceWithStreamingResponse(client.lists)
-        self.networks = resources.NetworksResourceWithStreamingResponse(client.networks)
-        self.reviews = resources.ReviewsResourceWithStreamingResponse(client.reviews)
-        self.person = resources.PersonResourceWithStreamingResponse(client.person)
-        self.tv_series = resources.TvSeriesResourceWithStreamingResponse(client.tv_series)
+        self.movies = movies.MoviesResourceWithStreamingResponse(client.movies)
+        self.tv = tv.TvResourceWithStreamingResponse(client.tv)
+        self.search = search.SearchResourceWithStreamingResponse(client.search)
+        self.people = people.PeopleResourceWithStreamingResponse(client.people)
+        self.configuration = configuration.ConfigurationResourceWithStreamingResponse(client.configuration)
+        self.discover_tv = discover_tv.DiscoverTvResourceWithStreamingResponse(client.discover_tv)
+        self.trending = trending.TrendingResourceWithStreamingResponse(client.trending)
+        self.trending_movies = trending_movies.TrendingMoviesResourceWithStreamingResponse(client.trending_movies)
+        self.trending_tv_shows = trending_tv_shows.TrendingTvShowsResourceWithStreamingResponse(
+            client.trending_tv_shows
+        )
+        self.episodes = episodes.EpisodesResourceWithStreamingResponse(client.episodes)
+        self.trending_people = trending_people.TrendingPeopleResourceWithStreamingResponse(client.trending_people)
+        self.authentication = authentication.AuthenticationResourceWithStreamingResponse(client.authentication)
+        self.find = find.FindResourceWithStreamingResponse(client.find)
+        self.tv_shows = tv_shows.TvShowsResourceWithStreamingResponse(client.tv_shows)
+        self.accounts = accounts.AccountsResourceWithStreamingResponse(client.accounts)
+        self.certifications = certifications.CertificationsResourceWithStreamingResponse(client.certifications)
+        self.collections = collections.CollectionsResourceWithStreamingResponse(client.collections)
+        self.companies = companies.CompaniesResourceWithStreamingResponse(client.companies)
+        self.credits = credits.CreditsResourceWithStreamingResponse(client.credits)
+        self.genres = genres.GenresResourceWithStreamingResponse(client.genres)
+        self.guest_sessions = guest_sessions.GuestSessionsResourceWithStreamingResponse(client.guest_sessions)
+        self.watch_providers = watch_providers.WatchProvidersResourceWithStreamingResponse(client.watch_providers)
+        self.keywords = keywords.KeywordsResourceWithStreamingResponse(client.keywords)
+        self.lists = lists.ListsResourceWithStreamingResponse(client.lists)
+        self.networks = networks.NetworksResourceWithStreamingResponse(client.networks)
+        self.reviews = reviews.ReviewsResourceWithStreamingResponse(client.reviews)
+        self.person = person.PersonResourceWithStreamingResponse(client.person)
+        self.tv_series = tv_series.TvSeriesResourceWithStreamingResponse(client.tv_series)
 
 
 class AsyncTmdbClientWithStreamedResponse:
     def __init__(self, client: AsyncTmdbClient) -> None:
-        self.movies = resources.AsyncMoviesResourceWithStreamingResponse(client.movies)
-        self.tv = resources.AsyncTvResourceWithStreamingResponse(client.tv)
-        self.search = resources.AsyncSearchResourceWithStreamingResponse(client.search)
-        self.people = resources.AsyncPeopleResourceWithStreamingResponse(client.people)
-        self.configuration = resources.AsyncConfigurationResourceWithStreamingResponse(client.configuration)
-        self.discover_tv = resources.AsyncDiscoverTvResourceWithStreamingResponse(client.discover_tv)
-        self.trending = resources.AsyncTrendingResourceWithStreamingResponse(client.trending)
-        self.trending_movies = resources.AsyncTrendingMoviesResourceWithStreamingResponse(client.trending_movies)
-        self.trending_tv_shows = resources.AsyncTrendingTvShowsResourceWithStreamingResponse(client.trending_tv_shows)
-        self.episodes = resources.AsyncEpisodesResourceWithStreamingResponse(client.episodes)
-        self.trending_people = resources.AsyncTrendingPeopleResourceWithStreamingResponse(client.trending_people)
-        self.authentication = resources.AsyncAuthenticationResourceWithStreamingResponse(client.authentication)
-        self.find = resources.AsyncFindResourceWithStreamingResponse(client.find)
-        self.tv_shows = resources.AsyncTvShowsResourceWithStreamingResponse(client.tv_shows)
-        self.accounts = resources.AsyncAccountsResourceWithStreamingResponse(client.accounts)
-        self.certifications = resources.AsyncCertificationsResourceWithStreamingResponse(client.certifications)
-        self.collections = resources.AsyncCollectionsResourceWithStreamingResponse(client.collections)
-        self.companies = resources.AsyncCompaniesResourceWithStreamingResponse(client.companies)
-        self.credits = resources.AsyncCreditsResourceWithStreamingResponse(client.credits)
-        self.genres = resources.AsyncGenresResourceWithStreamingResponse(client.genres)
-        self.guest_sessions = resources.AsyncGuestSessionsResourceWithStreamingResponse(client.guest_sessions)
-        self.watch_providers = resources.AsyncWatchProvidersResourceWithStreamingResponse(client.watch_providers)
-        self.keywords = resources.AsyncKeywordsResourceWithStreamingResponse(client.keywords)
-        self.lists = resources.AsyncListsResourceWithStreamingResponse(client.lists)
-        self.networks = resources.AsyncNetworksResourceWithStreamingResponse(client.networks)
-        self.reviews = resources.AsyncReviewsResourceWithStreamingResponse(client.reviews)
-        self.person = resources.AsyncPersonResourceWithStreamingResponse(client.person)
-        self.tv_series = resources.AsyncTvSeriesResourceWithStreamingResponse(client.tv_series)
+        self.movies = movies.AsyncMoviesResourceWithStreamingResponse(client.movies)
+        self.tv = tv.AsyncTvResourceWithStreamingResponse(client.tv)
+        self.search = search.AsyncSearchResourceWithStreamingResponse(client.search)
+        self.people = people.AsyncPeopleResourceWithStreamingResponse(client.people)
+        self.configuration = configuration.AsyncConfigurationResourceWithStreamingResponse(client.configuration)
+        self.discover_tv = discover_tv.AsyncDiscoverTvResourceWithStreamingResponse(client.discover_tv)
+        self.trending = trending.AsyncTrendingResourceWithStreamingResponse(client.trending)
+        self.trending_movies = trending_movies.AsyncTrendingMoviesResourceWithStreamingResponse(client.trending_movies)
+        self.trending_tv_shows = trending_tv_shows.AsyncTrendingTvShowsResourceWithStreamingResponse(
+            client.trending_tv_shows
+        )
+        self.episodes = episodes.AsyncEpisodesResourceWithStreamingResponse(client.episodes)
+        self.trending_people = trending_people.AsyncTrendingPeopleResourceWithStreamingResponse(client.trending_people)
+        self.authentication = authentication.AsyncAuthenticationResourceWithStreamingResponse(client.authentication)
+        self.find = find.AsyncFindResourceWithStreamingResponse(client.find)
+        self.tv_shows = tv_shows.AsyncTvShowsResourceWithStreamingResponse(client.tv_shows)
+        self.accounts = accounts.AsyncAccountsResourceWithStreamingResponse(client.accounts)
+        self.certifications = certifications.AsyncCertificationsResourceWithStreamingResponse(client.certifications)
+        self.collections = collections.AsyncCollectionsResourceWithStreamingResponse(client.collections)
+        self.companies = companies.AsyncCompaniesResourceWithStreamingResponse(client.companies)
+        self.credits = credits.AsyncCreditsResourceWithStreamingResponse(client.credits)
+        self.genres = genres.AsyncGenresResourceWithStreamingResponse(client.genres)
+        self.guest_sessions = guest_sessions.AsyncGuestSessionsResourceWithStreamingResponse(client.guest_sessions)
+        self.watch_providers = watch_providers.AsyncWatchProvidersResourceWithStreamingResponse(client.watch_providers)
+        self.keywords = keywords.AsyncKeywordsResourceWithStreamingResponse(client.keywords)
+        self.lists = lists.AsyncListsResourceWithStreamingResponse(client.lists)
+        self.networks = networks.AsyncNetworksResourceWithStreamingResponse(client.networks)
+        self.reviews = reviews.AsyncReviewsResourceWithStreamingResponse(client.reviews)
+        self.person = person.AsyncPersonResourceWithStreamingResponse(client.person)
+        self.tv_series = tv_series.AsyncTvSeriesResourceWithStreamingResponse(client.tv_series)
 
 
 Client = TmdbClient
diff --git a/src/tmdb_client/_models.py b/src/tmdb_client/_models.py
index 6cb469e..d56ea1d 100644
--- a/src/tmdb_client/_models.py
+++ b/src/tmdb_client/_models.py
@@ -46,6 +46,7 @@
     strip_not_given,
     extract_type_arg,
     is_annotated_type,
+    is_type_alias_type,
     strip_annotated_type,
 )
 from ._compat import (
@@ -428,6 +429,8 @@ def construct_type(*, value: object, type_: object) -> object:
     # we allow `object` as the input type because otherwise, passing things like
     # `Literal['value']` will be reported as a type error by type checkers
     type_ = cast("type[object]", type_)
+    if is_type_alias_type(type_):
+        type_ = type_.__value__  # type: ignore[unreachable]
 
     # unwrap `Annotated[T, ...]` -> `T`
     if is_annotated_type(type_):
@@ -485,7 +488,11 @@ def construct_type(*, value: object, type_: object) -> object:
         _, items_type = get_args(type_)  # Dict[_, items_type]
         return {key: construct_type(value=item, type_=items_type) for key, item in value.items()}
 
-    if not is_literal_type(type_) and (issubclass(origin, BaseModel) or issubclass(origin, GenericModel)):
+    if (
+        not is_literal_type(type_)
+        and inspect.isclass(origin)
+        and (issubclass(origin, BaseModel) or issubclass(origin, GenericModel))
+    ):
         if is_list(value):
             return [cast(Any, type_).construct(**entry) if is_mapping(entry) else entry for entry in value]
 
diff --git a/src/tmdb_client/_response.py b/src/tmdb_client/_response.py
index 2d46503..b4a7a95 100644
--- a/src/tmdb_client/_response.py
+++ b/src/tmdb_client/_response.py
@@ -25,7 +25,7 @@
 import pydantic
 
 from ._types import NoneType
-from ._utils import is_given, extract_type_arg, is_annotated_type, extract_type_var_from_base
+from ._utils import is_given, extract_type_arg, is_annotated_type, is_type_alias_type, extract_type_var_from_base
 from ._models import BaseModel, is_basemodel
 from ._constants import RAW_RESPONSE_HEADER, OVERRIDE_CAST_TO_HEADER
 from ._streaming import Stream, AsyncStream, is_stream_class_type, extract_stream_chunk_type
@@ -126,9 +126,15 @@ def __repr__(self) -> str:
         )
 
     def _parse(self, *, to: type[_T] | None = None) -> R | _T:
+        cast_to = to if to is not None else self._cast_to
+
+        # unwrap `TypeAlias('Name', T)` -> `T`
+        if is_type_alias_type(cast_to):
+            cast_to = cast_to.__value__  # type: ignore[unreachable]
+
         # unwrap `Annotated[T, ...]` -> `T`
-        if to and is_annotated_type(to):
-            to = extract_type_arg(to, 0)
+        if cast_to and is_annotated_type(cast_to):
+            cast_to = extract_type_arg(cast_to, 0)
 
         if self._is_sse_stream:
             if to:
@@ -164,18 +170,12 @@ def _parse(self, *, to: type[_T] | None = None) -> R | _T:
             return cast(
                 R,
                 stream_cls(
-                    cast_to=self._cast_to,
+                    cast_to=cast_to,
                     response=self.http_response,
                     client=cast(Any, self._client),
                 ),
             )
 
-        cast_to = to if to is not None else self._cast_to
-
-        # unwrap `Annotated[T, ...]` -> `T`
-        if is_annotated_type(cast_to):
-            cast_to = extract_type_arg(cast_to, 0)
-
         if cast_to is NoneType:
             return cast(R, None)
 
diff --git a/src/tmdb_client/_types.py b/src/tmdb_client/_types.py
index 03d59fe..b4014bf 100644
--- a/src/tmdb_client/_types.py
+++ b/src/tmdb_client/_types.py
@@ -192,10 +192,8 @@ def get(self, __key: str) -> str | None: ...
 StrBytesIntFloat = Union[str, bytes, int, float]
 
 # Note: copied from Pydantic
-# https://github.com/pydantic/pydantic/blob/32ea570bf96e84234d2992e1ddf40ab8a565925a/pydantic/main.py#L49
-IncEx: TypeAlias = Union[
-    Set[int], Set[str], Mapping[int, Union["IncEx", Literal[True]]], Mapping[str, Union["IncEx", Literal[True]]]
-]
+# https://github.com/pydantic/pydantic/blob/6f31f8f68ef011f84357330186f603ff295312fd/pydantic/main.py#L79
+IncEx: TypeAlias = Union[Set[int], Set[str], Mapping[int, Union["IncEx", bool]], Mapping[str, Union["IncEx", bool]]]
 
 PostParser = Callable[[Any], Any]
 
diff --git a/src/tmdb_client/_utils/__init__.py b/src/tmdb_client/_utils/__init__.py
index a7cff3c..d4fda26 100644
--- a/src/tmdb_client/_utils/__init__.py
+++ b/src/tmdb_client/_utils/__init__.py
@@ -39,6 +39,7 @@
     is_iterable_type as is_iterable_type,
     is_required_type as is_required_type,
     is_annotated_type as is_annotated_type,
+    is_type_alias_type as is_type_alias_type,
     strip_annotated_type as strip_annotated_type,
     extract_type_var_from_base as extract_type_var_from_base,
 )
diff --git a/src/tmdb_client/_utils/_typing.py b/src/tmdb_client/_utils/_typing.py
index c036991..278749b 100644
--- a/src/tmdb_client/_utils/_typing.py
+++ b/src/tmdb_client/_utils/_typing.py
@@ -1,8 +1,17 @@
 from __future__ import annotations
 
+import sys
+import typing
+import typing_extensions
 from typing import Any, TypeVar, Iterable, cast
 from collections import abc as _c_abc
-from typing_extensions import Required, Annotated, get_args, get_origin
+from typing_extensions import (
+    TypeIs,
+    Required,
+    Annotated,
+    get_args,
+    get_origin,
+)
 
 from .._types import InheritsGeneric
 from .._compat import is_union as _is_union
@@ -36,6 +45,26 @@ def is_typevar(typ: type) -> bool:
     return type(typ) == TypeVar  # type: ignore
 
 
+_TYPE_ALIAS_TYPES: tuple[type[typing_extensions.TypeAliasType], ...] = (typing_extensions.TypeAliasType,)
+if sys.version_info >= (3, 12):
+    _TYPE_ALIAS_TYPES = (*_TYPE_ALIAS_TYPES, typing.TypeAliasType)
+
+
+def is_type_alias_type(tp: Any, /) -> TypeIs[typing_extensions.TypeAliasType]:
+    """Return whether the provided argument is an instance of `TypeAliasType`.
+
+    ```python
+    type Int = int
+    is_type_alias_type(Int)
+    # > True
+    Str = TypeAliasType("Str", str)
+    is_type_alias_type(Str)
+    # > True
+    ```
+    """
+    return isinstance(tp, _TYPE_ALIAS_TYPES)
+
+
 # Extracts T from Annotated[T, ...] or from Required[Annotated[T, ...]]
 def strip_annotated_type(typ: type) -> type:
     if is_required_type(typ) or is_annotated_type(typ):
diff --git a/src/tmdb_client/_version.py b/src/tmdb_client/_version.py
index 0124ad1..ee03c65 100644
--- a/src/tmdb_client/_version.py
+++ b/src/tmdb_client/_version.py
@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "tmdb_client"
-__version__ = "0.0.1-alpha.0"
+__version__ = "0.0.1-alpha.1"  # x-release-please-version
diff --git a/src/tmdb_client/resources/accounts/accounts.py b/src/tmdb_client/resources/accounts/accounts.py
index 0a33916..1ade776 100644
--- a/src/tmdb_client/resources/accounts/accounts.py
+++ b/src/tmdb_client/resources/accounts/accounts.py
@@ -12,28 +12,12 @@
     ListsResourceWithStreamingResponse,
     AsyncListsResourceWithStreamingResponse,
 )
-from .rated import (
-    RatedResource,
-    AsyncRatedResource,
-    RatedResourceWithRawResponse,
-    AsyncRatedResourceWithRawResponse,
-    RatedResourceWithStreamingResponse,
-    AsyncRatedResourceWithStreamingResponse,
-)
 from ...types import account_retrieve_params
 from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
 from ..._utils import (
     maybe_transform,
     async_maybe_transform,
 )
-from .favorite import (
-    FavoriteResource,
-    AsyncFavoriteResource,
-    FavoriteResourceWithRawResponse,
-    AsyncFavoriteResourceWithRawResponse,
-    FavoriteResourceWithStreamingResponse,
-    AsyncFavoriteResourceWithStreamingResponse,
-)
 from ..._compat import cached_property
 from .watchlist import (
     WatchlistResource,
@@ -50,7 +34,14 @@
     async_to_raw_response_wrapper,
     async_to_streamed_response_wrapper,
 )
-from .rated.rated import RatedResource, AsyncRatedResource
+from .rated.rated import (
+    RatedResource,
+    AsyncRatedResource,
+    RatedResourceWithRawResponse,
+    AsyncRatedResourceWithRawResponse,
+    RatedResourceWithStreamingResponse,
+    AsyncRatedResourceWithStreamingResponse,
+)
 from .watchlist_tv import (
     WatchlistTvResource,
     AsyncWatchlistTvResource,
@@ -68,7 +59,14 @@
     WatchlistMoviesResourceWithStreamingResponse,
     AsyncWatchlistMoviesResourceWithStreamingResponse,
 )
-from .favorite.favorite import FavoriteResource, AsyncFavoriteResource
+from .favorite.favorite import (
+    FavoriteResource,
+    AsyncFavoriteResource,
+    FavoriteResourceWithRawResponse,
+    AsyncFavoriteResourceWithRawResponse,
+    FavoriteResourceWithStreamingResponse,
+    AsyncFavoriteResourceWithStreamingResponse,
+)
 from ...types.account_retrieve_response import AccountRetrieveResponse
 
 __all__ = ["AccountsResource", "AsyncAccountsResource"]
@@ -105,7 +103,7 @@ def with_raw_response(self) -> AccountsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AccountsResourceWithRawResponse(self)
 
@@ -114,7 +112,7 @@ def with_streaming_response(self) -> AccountsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AccountsResourceWithStreamingResponse(self)
 
@@ -186,7 +184,7 @@ def with_raw_response(self) -> AsyncAccountsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncAccountsResourceWithRawResponse(self)
 
@@ -195,7 +193,7 @@ def with_streaming_response(self) -> AsyncAccountsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncAccountsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/accounts/favorite/favorite.py b/src/tmdb_client/resources/accounts/favorite/favorite.py
index a65d699..78c6dcb 100644
--- a/src/tmdb_client/resources/accounts/favorite/favorite.py
+++ b/src/tmdb_client/resources/accounts/favorite/favorite.py
@@ -55,7 +55,7 @@ def with_raw_response(self) -> FavoriteResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return FavoriteResourceWithRawResponse(self)
 
@@ -64,7 +64,7 @@ def with_streaming_response(self) -> FavoriteResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return FavoriteResourceWithStreamingResponse(self)
 
@@ -122,7 +122,7 @@ def with_raw_response(self) -> AsyncFavoriteResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncFavoriteResourceWithRawResponse(self)
 
@@ -131,7 +131,7 @@ def with_streaming_response(self) -> AsyncFavoriteResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncFavoriteResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/accounts/favorite/movies.py b/src/tmdb_client/resources/accounts/favorite/movies.py
index 47ea2c1..38257d7 100644
--- a/src/tmdb_client/resources/accounts/favorite/movies.py
+++ b/src/tmdb_client/resources/accounts/favorite/movies.py
@@ -33,7 +33,7 @@ def with_raw_response(self) -> MoviesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return MoviesResourceWithRawResponse(self)
 
@@ -42,7 +42,7 @@ def with_streaming_response(self) -> MoviesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return MoviesResourceWithStreamingResponse(self)
 
@@ -101,7 +101,7 @@ def with_raw_response(self) -> AsyncMoviesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncMoviesResourceWithRawResponse(self)
 
@@ -110,7 +110,7 @@ def with_streaming_response(self) -> AsyncMoviesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncMoviesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/accounts/favorite/tv.py b/src/tmdb_client/resources/accounts/favorite/tv.py
index 9e4b46a..9704ce7 100644
--- a/src/tmdb_client/resources/accounts/favorite/tv.py
+++ b/src/tmdb_client/resources/accounts/favorite/tv.py
@@ -33,7 +33,7 @@ def with_raw_response(self) -> TvResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return TvResourceWithRawResponse(self)
 
@@ -42,7 +42,7 @@ def with_streaming_response(self) -> TvResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return TvResourceWithStreamingResponse(self)
 
@@ -101,7 +101,7 @@ def with_raw_response(self) -> AsyncTvResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncTvResourceWithRawResponse(self)
 
@@ -110,7 +110,7 @@ def with_streaming_response(self) -> AsyncTvResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncTvResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/accounts/lists.py b/src/tmdb_client/resources/accounts/lists.py
index ff275f1..a79305a 100644
--- a/src/tmdb_client/resources/accounts/lists.py
+++ b/src/tmdb_client/resources/accounts/lists.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> ListsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ListsResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> ListsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ListsResourceWithStreamingResponse(self)
 
@@ -95,7 +95,7 @@ def with_raw_response(self) -> AsyncListsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncListsResourceWithRawResponse(self)
 
@@ -104,7 +104,7 @@ def with_streaming_response(self) -> AsyncListsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncListsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/accounts/rated/movies.py b/src/tmdb_client/resources/accounts/rated/movies.py
index f922c67..b15b8e5 100644
--- a/src/tmdb_client/resources/accounts/rated/movies.py
+++ b/src/tmdb_client/resources/accounts/rated/movies.py
@@ -33,7 +33,7 @@ def with_raw_response(self) -> MoviesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return MoviesResourceWithRawResponse(self)
 
@@ -42,7 +42,7 @@ def with_streaming_response(self) -> MoviesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return MoviesResourceWithStreamingResponse(self)
 
@@ -101,7 +101,7 @@ def with_raw_response(self) -> AsyncMoviesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncMoviesResourceWithRawResponse(self)
 
@@ -110,7 +110,7 @@ def with_streaming_response(self) -> AsyncMoviesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncMoviesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/accounts/rated/rated.py b/src/tmdb_client/resources/accounts/rated/rated.py
index e450421..f545f3e 100644
--- a/src/tmdb_client/resources/accounts/rated/rated.py
+++ b/src/tmdb_client/resources/accounts/rated/rated.py
@@ -51,7 +51,7 @@ def with_raw_response(self) -> RatedResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return RatedResourceWithRawResponse(self)
 
@@ -60,7 +60,7 @@ def with_streaming_response(self) -> RatedResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return RatedResourceWithStreamingResponse(self)
 
@@ -84,7 +84,7 @@ def with_raw_response(self) -> AsyncRatedResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncRatedResourceWithRawResponse(self)
 
@@ -93,7 +93,7 @@ def with_streaming_response(self) -> AsyncRatedResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncRatedResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/accounts/rated/tv.py b/src/tmdb_client/resources/accounts/rated/tv.py
index 0ff8c9f..866716c 100644
--- a/src/tmdb_client/resources/accounts/rated/tv.py
+++ b/src/tmdb_client/resources/accounts/rated/tv.py
@@ -33,7 +33,7 @@ def with_raw_response(self) -> TvResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return TvResourceWithRawResponse(self)
 
@@ -42,7 +42,7 @@ def with_streaming_response(self) -> TvResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return TvResourceWithStreamingResponse(self)
 
@@ -101,7 +101,7 @@ def with_raw_response(self) -> AsyncTvResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncTvResourceWithRawResponse(self)
 
@@ -110,7 +110,7 @@ def with_streaming_response(self) -> AsyncTvResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncTvResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/accounts/rated/tv_episodes.py b/src/tmdb_client/resources/accounts/rated/tv_episodes.py
index 047d727..32003b2 100644
--- a/src/tmdb_client/resources/accounts/rated/tv_episodes.py
+++ b/src/tmdb_client/resources/accounts/rated/tv_episodes.py
@@ -33,7 +33,7 @@ def with_raw_response(self) -> TvEpisodesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return TvEpisodesResourceWithRawResponse(self)
 
@@ -42,7 +42,7 @@ def with_streaming_response(self) -> TvEpisodesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return TvEpisodesResourceWithStreamingResponse(self)
 
@@ -101,7 +101,7 @@ def with_raw_response(self) -> AsyncTvEpisodesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncTvEpisodesResourceWithRawResponse(self)
 
@@ -110,7 +110,7 @@ def with_streaming_response(self) -> AsyncTvEpisodesResourceWithStreamingRespons
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncTvEpisodesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/accounts/watchlist.py b/src/tmdb_client/resources/accounts/watchlist.py
index ae375f7..307e4c5 100644
--- a/src/tmdb_client/resources/accounts/watchlist.py
+++ b/src/tmdb_client/resources/accounts/watchlist.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> WatchlistResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return WatchlistResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> WatchlistResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return WatchlistResourceWithStreamingResponse(self)
 
@@ -90,7 +90,7 @@ def with_raw_response(self) -> AsyncWatchlistResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncWatchlistResourceWithRawResponse(self)
 
@@ -99,7 +99,7 @@ def with_streaming_response(self) -> AsyncWatchlistResourceWithStreamingResponse
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncWatchlistResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/accounts/watchlist_movies.py b/src/tmdb_client/resources/accounts/watchlist_movies.py
index 03768e7..61fd4f0 100644
--- a/src/tmdb_client/resources/accounts/watchlist_movies.py
+++ b/src/tmdb_client/resources/accounts/watchlist_movies.py
@@ -33,7 +33,7 @@ def with_raw_response(self) -> WatchlistMoviesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return WatchlistMoviesResourceWithRawResponse(self)
 
@@ -42,7 +42,7 @@ def with_streaming_response(self) -> WatchlistMoviesResourceWithStreamingRespons
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return WatchlistMoviesResourceWithStreamingResponse(self)
 
@@ -101,7 +101,7 @@ def with_raw_response(self) -> AsyncWatchlistMoviesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncWatchlistMoviesResourceWithRawResponse(self)
 
@@ -110,7 +110,7 @@ def with_streaming_response(self) -> AsyncWatchlistMoviesResourceWithStreamingRe
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncWatchlistMoviesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/accounts/watchlist_tv.py b/src/tmdb_client/resources/accounts/watchlist_tv.py
index 7a6f568..4179074 100644
--- a/src/tmdb_client/resources/accounts/watchlist_tv.py
+++ b/src/tmdb_client/resources/accounts/watchlist_tv.py
@@ -33,7 +33,7 @@ def with_raw_response(self) -> WatchlistTvResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return WatchlistTvResourceWithRawResponse(self)
 
@@ -42,7 +42,7 @@ def with_streaming_response(self) -> WatchlistTvResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return WatchlistTvResourceWithStreamingResponse(self)
 
@@ -101,7 +101,7 @@ def with_raw_response(self) -> AsyncWatchlistTvResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncWatchlistTvResourceWithRawResponse(self)
 
@@ -110,7 +110,7 @@ def with_streaming_response(self) -> AsyncWatchlistTvResourceWithStreamingRespon
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncWatchlistTvResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/authentication/authentication.py b/src/tmdb_client/resources/authentication/authentication.py
index bd85f29..f0d5f8f 100644
--- a/src/tmdb_client/resources/authentication/authentication.py
+++ b/src/tmdb_client/resources/authentication/authentication.py
@@ -62,7 +62,7 @@ def with_raw_response(self) -> AuthenticationResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AuthenticationResourceWithRawResponse(self)
 
@@ -71,7 +71,7 @@ def with_streaming_response(self) -> AuthenticationResourceWithStreamingResponse
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AuthenticationResourceWithStreamingResponse(self)
 
@@ -114,7 +114,7 @@ def with_raw_response(self) -> AsyncAuthenticationResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncAuthenticationResourceWithRawResponse(self)
 
@@ -123,7 +123,7 @@ def with_streaming_response(self) -> AsyncAuthenticationResourceWithStreamingRes
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncAuthenticationResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/authentication/guest_session.py b/src/tmdb_client/resources/authentication/guest_session.py
index df6bc5e..72572ca 100644
--- a/src/tmdb_client/resources/authentication/guest_session.py
+++ b/src/tmdb_client/resources/authentication/guest_session.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> GuestSessionResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return GuestSessionResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> GuestSessionResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return GuestSessionResourceWithStreamingResponse(self)
 
@@ -66,7 +66,7 @@ def with_raw_response(self) -> AsyncGuestSessionResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncGuestSessionResourceWithRawResponse(self)
 
@@ -75,7 +75,7 @@ def with_streaming_response(self) -> AsyncGuestSessionResourceWithStreamingRespo
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncGuestSessionResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/authentication/session.py b/src/tmdb_client/resources/authentication/session.py
index 954dab9..b4c9dc9 100644
--- a/src/tmdb_client/resources/authentication/session.py
+++ b/src/tmdb_client/resources/authentication/session.py
@@ -33,7 +33,7 @@ def with_raw_response(self) -> SessionResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return SessionResourceWithRawResponse(self)
 
@@ -42,7 +42,7 @@ def with_streaming_response(self) -> SessionResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return SessionResourceWithStreamingResponse(self)
 
@@ -150,7 +150,7 @@ def with_raw_response(self) -> AsyncSessionResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncSessionResourceWithRawResponse(self)
 
@@ -159,7 +159,7 @@ def with_streaming_response(self) -> AsyncSessionResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncSessionResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/authentication/token.py b/src/tmdb_client/resources/authentication/token.py
index 1ce1329..bd93740 100644
--- a/src/tmdb_client/resources/authentication/token.py
+++ b/src/tmdb_client/resources/authentication/token.py
@@ -32,7 +32,7 @@ def with_raw_response(self) -> TokenResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return TokenResourceWithRawResponse(self)
 
@@ -41,7 +41,7 @@ def with_streaming_response(self) -> TokenResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return TokenResourceWithStreamingResponse(self)
 
@@ -105,7 +105,7 @@ def with_raw_response(self) -> AsyncTokenResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncTokenResourceWithRawResponse(self)
 
@@ -114,7 +114,7 @@ def with_streaming_response(self) -> AsyncTokenResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncTokenResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/certifications/certifications.py b/src/tmdb_client/resources/certifications/certifications.py
index 980dacf..3e0ec7c 100644
--- a/src/tmdb_client/resources/certifications/certifications.py
+++ b/src/tmdb_client/resources/certifications/certifications.py
@@ -39,7 +39,7 @@ def with_raw_response(self) -> CertificationsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return CertificationsResourceWithRawResponse(self)
 
@@ -48,7 +48,7 @@ def with_streaming_response(self) -> CertificationsResourceWithStreamingResponse
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return CertificationsResourceWithStreamingResponse(self)
 
@@ -68,7 +68,7 @@ def with_raw_response(self) -> AsyncCertificationsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncCertificationsResourceWithRawResponse(self)
 
@@ -77,7 +77,7 @@ def with_streaming_response(self) -> AsyncCertificationsResourceWithStreamingRes
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncCertificationsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/certifications/movie.py b/src/tmdb_client/resources/certifications/movie.py
index f051287..6e86f91 100644
--- a/src/tmdb_client/resources/certifications/movie.py
+++ b/src/tmdb_client/resources/certifications/movie.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> MovieResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return MovieResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> MovieResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return MovieResourceWithStreamingResponse(self)
 
@@ -68,7 +68,7 @@ def with_raw_response(self) -> AsyncMovieResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncMovieResourceWithRawResponse(self)
 
@@ -77,7 +77,7 @@ def with_streaming_response(self) -> AsyncMovieResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncMovieResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/certifications/tv.py b/src/tmdb_client/resources/certifications/tv.py
index 5e6bed2..2fa6bd3 100644
--- a/src/tmdb_client/resources/certifications/tv.py
+++ b/src/tmdb_client/resources/certifications/tv.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> TvResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return TvResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> TvResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return TvResourceWithStreamingResponse(self)
 
@@ -66,7 +66,7 @@ def with_raw_response(self) -> AsyncTvResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncTvResourceWithRawResponse(self)
 
@@ -75,7 +75,7 @@ def with_streaming_response(self) -> AsyncTvResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncTvResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/collections/collections.py b/src/tmdb_client/resources/collections/collections.py
index 2a21d05..72f04b9 100644
--- a/src/tmdb_client/resources/collections/collections.py
+++ b/src/tmdb_client/resources/collections/collections.py
@@ -55,7 +55,7 @@ def with_raw_response(self) -> CollectionsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return CollectionsResourceWithRawResponse(self)
 
@@ -64,7 +64,7 @@ def with_streaming_response(self) -> CollectionsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return CollectionsResourceWithStreamingResponse(self)
 
@@ -120,7 +120,7 @@ def with_raw_response(self) -> AsyncCollectionsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncCollectionsResourceWithRawResponse(self)
 
@@ -129,7 +129,7 @@ def with_streaming_response(self) -> AsyncCollectionsResourceWithStreamingRespon
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncCollectionsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/collections/images.py b/src/tmdb_client/resources/collections/images.py
index dff8f96..fc4cf4c 100644
--- a/src/tmdb_client/resources/collections/images.py
+++ b/src/tmdb_client/resources/collections/images.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> ImagesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ImagesResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> ImagesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ImagesResourceWithStreamingResponse(self)
 
@@ -99,7 +99,7 @@ def with_raw_response(self) -> AsyncImagesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncImagesResourceWithRawResponse(self)
 
@@ -108,7 +108,7 @@ def with_streaming_response(self) -> AsyncImagesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncImagesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/collections/translations.py b/src/tmdb_client/resources/collections/translations.py
index 7368010..9b0156b 100644
--- a/src/tmdb_client/resources/collections/translations.py
+++ b/src/tmdb_client/resources/collections/translations.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> TranslationsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return TranslationsResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> TranslationsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return TranslationsResourceWithStreamingResponse(self)
 
@@ -78,7 +78,7 @@ def with_raw_response(self) -> AsyncTranslationsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncTranslationsResourceWithRawResponse(self)
 
@@ -87,7 +87,7 @@ def with_streaming_response(self) -> AsyncTranslationsResourceWithStreamingRespo
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncTranslationsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/companies/alternative_names.py b/src/tmdb_client/resources/companies/alternative_names.py
index 69c2c59..b32bf0a 100644
--- a/src/tmdb_client/resources/companies/alternative_names.py
+++ b/src/tmdb_client/resources/companies/alternative_names.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> AlternativeNamesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AlternativeNamesResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> AlternativeNamesResourceWithStreamingRespon
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AlternativeNamesResourceWithStreamingResponse(self)
 
@@ -78,7 +78,7 @@ def with_raw_response(self) -> AsyncAlternativeNamesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncAlternativeNamesResourceWithRawResponse(self)
 
@@ -87,7 +87,7 @@ def with_streaming_response(self) -> AsyncAlternativeNamesResourceWithStreamingR
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncAlternativeNamesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/companies/companies.py b/src/tmdb_client/resources/companies/companies.py
index 78e5128..6efa557 100644
--- a/src/tmdb_client/resources/companies/companies.py
+++ b/src/tmdb_client/resources/companies/companies.py
@@ -50,7 +50,7 @@ def with_raw_response(self) -> CompaniesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return CompaniesResourceWithRawResponse(self)
 
@@ -59,7 +59,7 @@ def with_streaming_response(self) -> CompaniesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return CompaniesResourceWithStreamingResponse(self)
 
@@ -110,7 +110,7 @@ def with_raw_response(self) -> AsyncCompaniesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncCompaniesResourceWithRawResponse(self)
 
@@ -119,7 +119,7 @@ def with_streaming_response(self) -> AsyncCompaniesResourceWithStreamingResponse
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncCompaniesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/companies/images.py b/src/tmdb_client/resources/companies/images.py
index c1d336f..55998b1 100644
--- a/src/tmdb_client/resources/companies/images.py
+++ b/src/tmdb_client/resources/companies/images.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> ImagesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ImagesResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> ImagesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ImagesResourceWithStreamingResponse(self)
 
@@ -78,7 +78,7 @@ def with_raw_response(self) -> AsyncImagesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncImagesResourceWithRawResponse(self)
 
@@ -87,7 +87,7 @@ def with_streaming_response(self) -> AsyncImagesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncImagesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/configuration/configuration.py b/src/tmdb_client/resources/configuration/configuration.py
index 6046565..b9cff48 100644
--- a/src/tmdb_client/resources/configuration/configuration.py
+++ b/src/tmdb_client/resources/configuration/configuration.py
@@ -86,7 +86,7 @@ def with_raw_response(self) -> ConfigurationResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ConfigurationResourceWithRawResponse(self)
 
@@ -95,7 +95,7 @@ def with_streaming_response(self) -> ConfigurationResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ConfigurationResourceWithStreamingResponse(self)
 
@@ -146,7 +146,7 @@ def with_raw_response(self) -> AsyncConfigurationResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncConfigurationResourceWithRawResponse(self)
 
@@ -155,7 +155,7 @@ def with_streaming_response(self) -> AsyncConfigurationResourceWithStreamingResp
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncConfigurationResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/configuration/countries.py b/src/tmdb_client/resources/configuration/countries.py
index 67cce2d..39bbe64 100644
--- a/src/tmdb_client/resources/configuration/countries.py
+++ b/src/tmdb_client/resources/configuration/countries.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> CountriesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return CountriesResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> CountriesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return CountriesResourceWithStreamingResponse(self)
 
@@ -87,7 +87,7 @@ def with_raw_response(self) -> AsyncCountriesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncCountriesResourceWithRawResponse(self)
 
@@ -96,7 +96,7 @@ def with_streaming_response(self) -> AsyncCountriesResourceWithStreamingResponse
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncCountriesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/configuration/jobs.py b/src/tmdb_client/resources/configuration/jobs.py
index 17b1ea0..021e25c 100644
--- a/src/tmdb_client/resources/configuration/jobs.py
+++ b/src/tmdb_client/resources/configuration/jobs.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> JobsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return JobsResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> JobsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return JobsResourceWithStreamingResponse(self)
 
@@ -66,7 +66,7 @@ def with_raw_response(self) -> AsyncJobsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncJobsResourceWithRawResponse(self)
 
@@ -75,7 +75,7 @@ def with_streaming_response(self) -> AsyncJobsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncJobsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/configuration/languages.py b/src/tmdb_client/resources/configuration/languages.py
index 13dde83..d71c454 100644
--- a/src/tmdb_client/resources/configuration/languages.py
+++ b/src/tmdb_client/resources/configuration/languages.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> LanguagesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return LanguagesResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> LanguagesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return LanguagesResourceWithStreamingResponse(self)
 
@@ -66,7 +66,7 @@ def with_raw_response(self) -> AsyncLanguagesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncLanguagesResourceWithRawResponse(self)
 
@@ -75,7 +75,7 @@ def with_streaming_response(self) -> AsyncLanguagesResourceWithStreamingResponse
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncLanguagesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/configuration/primary_translations.py b/src/tmdb_client/resources/configuration/primary_translations.py
index 7165f9c..48e7d85 100644
--- a/src/tmdb_client/resources/configuration/primary_translations.py
+++ b/src/tmdb_client/resources/configuration/primary_translations.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> PrimaryTranslationsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return PrimaryTranslationsResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> PrimaryTranslationsResourceWithStreamingRes
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return PrimaryTranslationsResourceWithStreamingResponse(self)
 
@@ -66,7 +66,7 @@ def with_raw_response(self) -> AsyncPrimaryTranslationsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncPrimaryTranslationsResourceWithRawResponse(self)
 
@@ -75,7 +75,7 @@ def with_streaming_response(self) -> AsyncPrimaryTranslationsResourceWithStreami
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncPrimaryTranslationsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/configuration/timezones.py b/src/tmdb_client/resources/configuration/timezones.py
index a50fa91..368767b 100644
--- a/src/tmdb_client/resources/configuration/timezones.py
+++ b/src/tmdb_client/resources/configuration/timezones.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> TimezonesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return TimezonesResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> TimezonesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return TimezonesResourceWithStreamingResponse(self)
 
@@ -66,7 +66,7 @@ def with_raw_response(self) -> AsyncTimezonesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncTimezonesResourceWithRawResponse(self)
 
@@ -75,7 +75,7 @@ def with_streaming_response(self) -> AsyncTimezonesResourceWithStreamingResponse
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncTimezonesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/credits.py b/src/tmdb_client/resources/credits.py
index 717c456..bcd2893 100644
--- a/src/tmdb_client/resources/credits.py
+++ b/src/tmdb_client/resources/credits.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> CreditsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return CreditsResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> CreditsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return CreditsResourceWithStreamingResponse(self)
 
@@ -80,7 +80,7 @@ def with_raw_response(self) -> AsyncCreditsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncCreditsResourceWithRawResponse(self)
 
@@ -89,7 +89,7 @@ def with_streaming_response(self) -> AsyncCreditsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncCreditsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/discover_tv.py b/src/tmdb_client/resources/discover_tv.py
index 154c2e7..b0e031f 100644
--- a/src/tmdb_client/resources/discover_tv.py
+++ b/src/tmdb_client/resources/discover_tv.py
@@ -33,7 +33,7 @@ def with_raw_response(self) -> DiscoverTvResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return DiscoverTvResourceWithRawResponse(self)
 
@@ -42,7 +42,7 @@ def with_streaming_response(self) -> DiscoverTvResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return DiscoverTvResourceWithStreamingResponse(self)
 
@@ -183,7 +183,7 @@ def with_raw_response(self) -> AsyncDiscoverTvResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncDiscoverTvResourceWithRawResponse(self)
 
@@ -192,7 +192,7 @@ def with_streaming_response(self) -> AsyncDiscoverTvResourceWithStreamingRespons
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncDiscoverTvResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/episodes.py b/src/tmdb_client/resources/episodes.py
index 1d9e197..edb3768 100644
--- a/src/tmdb_client/resources/episodes.py
+++ b/src/tmdb_client/resources/episodes.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> EpisodesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return EpisodesResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> EpisodesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return EpisodesResourceWithStreamingResponse(self)
 
@@ -97,7 +97,7 @@ def with_raw_response(self) -> AsyncEpisodesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncEpisodesResourceWithRawResponse(self)
 
@@ -106,7 +106,7 @@ def with_streaming_response(self) -> AsyncEpisodesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncEpisodesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/find.py b/src/tmdb_client/resources/find.py
index 68135e1..cf96524 100644
--- a/src/tmdb_client/resources/find.py
+++ b/src/tmdb_client/resources/find.py
@@ -33,7 +33,7 @@ def with_raw_response(self) -> FindResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return FindResourceWithRawResponse(self)
 
@@ -42,7 +42,7 @@ def with_streaming_response(self) -> FindResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return FindResourceWithStreamingResponse(self)
 
@@ -109,7 +109,7 @@ def with_raw_response(self) -> AsyncFindResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncFindResourceWithRawResponse(self)
 
@@ -118,7 +118,7 @@ def with_streaming_response(self) -> AsyncFindResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncFindResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/genres/genres.py b/src/tmdb_client/resources/genres/genres.py
index 5610fa0..d05426f 100644
--- a/src/tmdb_client/resources/genres/genres.py
+++ b/src/tmdb_client/resources/genres/genres.py
@@ -39,7 +39,7 @@ def with_raw_response(self) -> GenresResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return GenresResourceWithRawResponse(self)
 
@@ -48,7 +48,7 @@ def with_streaming_response(self) -> GenresResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return GenresResourceWithStreamingResponse(self)
 
@@ -68,7 +68,7 @@ def with_raw_response(self) -> AsyncGenresResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncGenresResourceWithRawResponse(self)
 
@@ -77,7 +77,7 @@ def with_streaming_response(self) -> AsyncGenresResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncGenresResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/genres/movies.py b/src/tmdb_client/resources/genres/movies.py
index 0d60129..d311dad 100644
--- a/src/tmdb_client/resources/genres/movies.py
+++ b/src/tmdb_client/resources/genres/movies.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> MoviesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return MoviesResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> MoviesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return MoviesResourceWithStreamingResponse(self)
 
@@ -87,7 +87,7 @@ def with_raw_response(self) -> AsyncMoviesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncMoviesResourceWithRawResponse(self)
 
@@ -96,7 +96,7 @@ def with_streaming_response(self) -> AsyncMoviesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncMoviesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/genres/tv.py b/src/tmdb_client/resources/genres/tv.py
index 9a4a6ac..1e0d39c 100644
--- a/src/tmdb_client/resources/genres/tv.py
+++ b/src/tmdb_client/resources/genres/tv.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> TvResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return TvResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> TvResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return TvResourceWithStreamingResponse(self)
 
@@ -87,7 +87,7 @@ def with_raw_response(self) -> AsyncTvResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncTvResourceWithRawResponse(self)
 
@@ -96,7 +96,7 @@ def with_streaming_response(self) -> AsyncTvResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncTvResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/guest_sessions/guest_sessions.py b/src/tmdb_client/resources/guest_sessions/guest_sessions.py
index 6ef63ba..cd9a071 100644
--- a/src/tmdb_client/resources/guest_sessions/guest_sessions.py
+++ b/src/tmdb_client/resources/guest_sessions/guest_sessions.py
@@ -2,7 +2,9 @@
 
 from __future__ import annotations
 
-from .rated import (
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from .rated.rated import (
     RatedResource,
     AsyncRatedResource,
     RatedResourceWithRawResponse,
@@ -10,9 +12,6 @@
     RatedResourceWithStreamingResponse,
     AsyncRatedResourceWithStreamingResponse,
 )
-from ..._compat import cached_property
-from ..._resource import SyncAPIResource, AsyncAPIResource
-from .rated.rated import RatedResource, AsyncRatedResource
 from .tv_episodes import (
     TvEpisodesResource,
     AsyncTvEpisodesResource,
@@ -40,7 +39,7 @@ def with_raw_response(self) -> GuestSessionsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return GuestSessionsResourceWithRawResponse(self)
 
@@ -49,7 +48,7 @@ def with_streaming_response(self) -> GuestSessionsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return GuestSessionsResourceWithStreamingResponse(self)
 
@@ -69,7 +68,7 @@ def with_raw_response(self) -> AsyncGuestSessionsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncGuestSessionsResourceWithRawResponse(self)
 
@@ -78,7 +77,7 @@ def with_streaming_response(self) -> AsyncGuestSessionsResourceWithStreamingResp
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncGuestSessionsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/guest_sessions/rated/movies.py b/src/tmdb_client/resources/guest_sessions/rated/movies.py
index c2c47fc..41e0dbc 100644
--- a/src/tmdb_client/resources/guest_sessions/rated/movies.py
+++ b/src/tmdb_client/resources/guest_sessions/rated/movies.py
@@ -33,7 +33,7 @@ def with_raw_response(self) -> MoviesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return MoviesResourceWithRawResponse(self)
 
@@ -42,7 +42,7 @@ def with_streaming_response(self) -> MoviesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return MoviesResourceWithStreamingResponse(self)
 
@@ -101,7 +101,7 @@ def with_raw_response(self) -> AsyncMoviesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncMoviesResourceWithRawResponse(self)
 
@@ -110,7 +110,7 @@ def with_streaming_response(self) -> AsyncMoviesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncMoviesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/guest_sessions/rated/rated.py b/src/tmdb_client/resources/guest_sessions/rated/rated.py
index dd3f7c5..98fe64e 100644
--- a/src/tmdb_client/resources/guest_sessions/rated/rated.py
+++ b/src/tmdb_client/resources/guest_sessions/rated/rated.py
@@ -39,7 +39,7 @@ def with_raw_response(self) -> RatedResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return RatedResourceWithRawResponse(self)
 
@@ -48,7 +48,7 @@ def with_streaming_response(self) -> RatedResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return RatedResourceWithStreamingResponse(self)
 
@@ -68,7 +68,7 @@ def with_raw_response(self) -> AsyncRatedResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncRatedResourceWithRawResponse(self)
 
@@ -77,7 +77,7 @@ def with_streaming_response(self) -> AsyncRatedResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncRatedResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/guest_sessions/rated/tv.py b/src/tmdb_client/resources/guest_sessions/rated/tv.py
index 03d5153..2485669 100644
--- a/src/tmdb_client/resources/guest_sessions/rated/tv.py
+++ b/src/tmdb_client/resources/guest_sessions/rated/tv.py
@@ -33,7 +33,7 @@ def with_raw_response(self) -> TvResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return TvResourceWithRawResponse(self)
 
@@ -42,7 +42,7 @@ def with_streaming_response(self) -> TvResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return TvResourceWithStreamingResponse(self)
 
@@ -101,7 +101,7 @@ def with_raw_response(self) -> AsyncTvResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncTvResourceWithRawResponse(self)
 
@@ -110,7 +110,7 @@ def with_streaming_response(self) -> AsyncTvResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncTvResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/guest_sessions/tv_episodes.py b/src/tmdb_client/resources/guest_sessions/tv_episodes.py
index 0d2d15e..9854709 100644
--- a/src/tmdb_client/resources/guest_sessions/tv_episodes.py
+++ b/src/tmdb_client/resources/guest_sessions/tv_episodes.py
@@ -33,7 +33,7 @@ def with_raw_response(self) -> TvEpisodesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return TvEpisodesResourceWithRawResponse(self)
 
@@ -42,7 +42,7 @@ def with_streaming_response(self) -> TvEpisodesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return TvEpisodesResourceWithStreamingResponse(self)
 
@@ -101,7 +101,7 @@ def with_raw_response(self) -> AsyncTvEpisodesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncTvEpisodesResourceWithRawResponse(self)
 
@@ -110,7 +110,7 @@ def with_streaming_response(self) -> AsyncTvEpisodesResourceWithStreamingRespons
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncTvEpisodesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/keywords/keywords.py b/src/tmdb_client/resources/keywords/keywords.py
index f3e0d58..ae8a628 100644
--- a/src/tmdb_client/resources/keywords/keywords.py
+++ b/src/tmdb_client/resources/keywords/keywords.py
@@ -44,7 +44,7 @@ def with_raw_response(self) -> KeywordsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return KeywordsResourceWithRawResponse(self)
 
@@ -53,7 +53,7 @@ def with_streaming_response(self) -> KeywordsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return KeywordsResourceWithStreamingResponse(self)
 
@@ -142,7 +142,7 @@ def with_raw_response(self) -> AsyncKeywordsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncKeywordsResourceWithRawResponse(self)
 
@@ -151,7 +151,7 @@ def with_streaming_response(self) -> AsyncKeywordsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncKeywordsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/keywords/movies.py b/src/tmdb_client/resources/keywords/movies.py
index 51173e9..c6056d2 100644
--- a/src/tmdb_client/resources/keywords/movies.py
+++ b/src/tmdb_client/resources/keywords/movies.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> MoviesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return MoviesResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> MoviesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return MoviesResourceWithStreamingResponse(self)
 
@@ -99,7 +99,7 @@ def with_raw_response(self) -> AsyncMoviesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncMoviesResourceWithRawResponse(self)
 
@@ -108,7 +108,7 @@ def with_streaming_response(self) -> AsyncMoviesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncMoviesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/lists.py b/src/tmdb_client/resources/lists.py
index 96d6e6d..9efb872 100644
--- a/src/tmdb_client/resources/lists.py
+++ b/src/tmdb_client/resources/lists.py
@@ -45,7 +45,7 @@ def with_raw_response(self) -> ListsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ListsResourceWithRawResponse(self)
 
@@ -54,7 +54,7 @@ def with_streaming_response(self) -> ListsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ListsResourceWithStreamingResponse(self)
 
@@ -344,7 +344,7 @@ def with_raw_response(self) -> AsyncListsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncListsResourceWithRawResponse(self)
 
@@ -353,7 +353,7 @@ def with_streaming_response(self) -> AsyncListsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncListsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/movies/account_states.py b/src/tmdb_client/resources/movies/account_states.py
index b3fea19..1c0a8b2 100644
--- a/src/tmdb_client/resources/movies/account_states.py
+++ b/src/tmdb_client/resources/movies/account_states.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> AccountStatesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AccountStatesResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> AccountStatesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AccountStatesResourceWithStreamingResponse(self)
 
@@ -95,7 +95,7 @@ def with_raw_response(self) -> AsyncAccountStatesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncAccountStatesResourceWithRawResponse(self)
 
@@ -104,7 +104,7 @@ def with_streaming_response(self) -> AsyncAccountStatesResourceWithStreamingResp
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncAccountStatesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/movies/alternative_titles.py b/src/tmdb_client/resources/movies/alternative_titles.py
index d6c67a8..aec5429 100644
--- a/src/tmdb_client/resources/movies/alternative_titles.py
+++ b/src/tmdb_client/resources/movies/alternative_titles.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> AlternativeTitlesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AlternativeTitlesResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> AlternativeTitlesResourceWithStreamingRespo
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AlternativeTitlesResourceWithStreamingResponse(self)
 
@@ -92,7 +92,7 @@ def with_raw_response(self) -> AsyncAlternativeTitlesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncAlternativeTitlesResourceWithRawResponse(self)
 
@@ -101,7 +101,7 @@ def with_streaming_response(self) -> AsyncAlternativeTitlesResourceWithStreaming
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncAlternativeTitlesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/movies/changes.py b/src/tmdb_client/resources/movies/changes.py
index 2ac4be2..21e776b 100644
--- a/src/tmdb_client/resources/movies/changes.py
+++ b/src/tmdb_client/resources/movies/changes.py
@@ -35,7 +35,7 @@ def with_raw_response(self) -> ChangesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ChangesResourceWithRawResponse(self)
 
@@ -44,7 +44,7 @@ def with_streaming_response(self) -> ChangesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ChangesResourceWithStreamingResponse(self)
 
@@ -145,7 +145,7 @@ def with_raw_response(self) -> AsyncChangesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncChangesResourceWithRawResponse(self)
 
@@ -154,7 +154,7 @@ def with_streaming_response(self) -> AsyncChangesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncChangesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/movies/credits.py b/src/tmdb_client/resources/movies/credits.py
index e5b96da..bc3941e 100644
--- a/src/tmdb_client/resources/movies/credits.py
+++ b/src/tmdb_client/resources/movies/credits.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> CreditsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return CreditsResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> CreditsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return CreditsResourceWithStreamingResponse(self)
 
@@ -88,7 +88,7 @@ def with_raw_response(self) -> AsyncCreditsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncCreditsResourceWithRawResponse(self)
 
@@ -97,7 +97,7 @@ def with_streaming_response(self) -> AsyncCreditsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncCreditsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/movies/external_ids.py b/src/tmdb_client/resources/movies/external_ids.py
index 738ce81..e781ef0 100644
--- a/src/tmdb_client/resources/movies/external_ids.py
+++ b/src/tmdb_client/resources/movies/external_ids.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> ExternalIDsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ExternalIDsResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> ExternalIDsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ExternalIDsResourceWithStreamingResponse(self)
 
@@ -78,7 +78,7 @@ def with_raw_response(self) -> AsyncExternalIDsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncExternalIDsResourceWithRawResponse(self)
 
@@ -87,7 +87,7 @@ def with_streaming_response(self) -> AsyncExternalIDsResourceWithStreamingRespon
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncExternalIDsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/movies/images.py b/src/tmdb_client/resources/movies/images.py
index e1d62d3..4d61082 100644
--- a/src/tmdb_client/resources/movies/images.py
+++ b/src/tmdb_client/resources/movies/images.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> ImagesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ImagesResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> ImagesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ImagesResourceWithStreamingResponse(self)
 
@@ -99,7 +99,7 @@ def with_raw_response(self) -> AsyncImagesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncImagesResourceWithRawResponse(self)
 
@@ -108,7 +108,7 @@ def with_streaming_response(self) -> AsyncImagesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncImagesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/movies/keywords.py b/src/tmdb_client/resources/movies/keywords.py
index a368747..d1725c0 100644
--- a/src/tmdb_client/resources/movies/keywords.py
+++ b/src/tmdb_client/resources/movies/keywords.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> KeywordsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return KeywordsResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> KeywordsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return KeywordsResourceWithStreamingResponse(self)
 
@@ -80,7 +80,7 @@ def with_raw_response(self) -> AsyncKeywordsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncKeywordsResourceWithRawResponse(self)
 
@@ -89,7 +89,7 @@ def with_streaming_response(self) -> AsyncKeywordsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncKeywordsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/movies/latest.py b/src/tmdb_client/resources/movies/latest.py
index ef085da..fb159aa 100644
--- a/src/tmdb_client/resources/movies/latest.py
+++ b/src/tmdb_client/resources/movies/latest.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> LatestResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return LatestResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> LatestResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return LatestResourceWithStreamingResponse(self)
 
@@ -66,7 +66,7 @@ def with_raw_response(self) -> AsyncLatestResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncLatestResourceWithRawResponse(self)
 
@@ -75,7 +75,7 @@ def with_streaming_response(self) -> AsyncLatestResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncLatestResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/movies/lists.py b/src/tmdb_client/resources/movies/lists.py
index cb3b635..0940aba 100644
--- a/src/tmdb_client/resources/movies/lists.py
+++ b/src/tmdb_client/resources/movies/lists.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> ListsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ListsResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> ListsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ListsResourceWithStreamingResponse(self)
 
@@ -95,7 +95,7 @@ def with_raw_response(self) -> AsyncListsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncListsResourceWithRawResponse(self)
 
@@ -104,7 +104,7 @@ def with_streaming_response(self) -> AsyncListsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncListsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/movies/movies.py b/src/tmdb_client/resources/movies/movies.py
index d2532e0..d29163f 100644
--- a/src/tmdb_client/resources/movies/movies.py
+++ b/src/tmdb_client/resources/movies/movies.py
@@ -283,7 +283,7 @@ def with_raw_response(self) -> MoviesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return MoviesResourceWithRawResponse(self)
 
@@ -292,7 +292,7 @@ def with_streaming_response(self) -> MoviesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return MoviesResourceWithStreamingResponse(self)
 
@@ -712,7 +712,7 @@ def with_raw_response(self) -> AsyncMoviesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncMoviesResourceWithRawResponse(self)
 
@@ -721,7 +721,7 @@ def with_streaming_response(self) -> AsyncMoviesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncMoviesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/movies/now_playing.py b/src/tmdb_client/resources/movies/now_playing.py
index b524d54..31c439c 100644
--- a/src/tmdb_client/resources/movies/now_playing.py
+++ b/src/tmdb_client/resources/movies/now_playing.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> NowPlayingResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return NowPlayingResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> NowPlayingResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return NowPlayingResourceWithStreamingResponse(self)
 
@@ -98,7 +98,7 @@ def with_raw_response(self) -> AsyncNowPlayingResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncNowPlayingResourceWithRawResponse(self)
 
@@ -107,7 +107,7 @@ def with_streaming_response(self) -> AsyncNowPlayingResourceWithStreamingRespons
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncNowPlayingResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/movies/popular.py b/src/tmdb_client/resources/movies/popular.py
index c14ca61..0a1647b 100644
--- a/src/tmdb_client/resources/movies/popular.py
+++ b/src/tmdb_client/resources/movies/popular.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> PopularResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return PopularResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> PopularResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return PopularResourceWithStreamingResponse(self)
 
@@ -98,7 +98,7 @@ def with_raw_response(self) -> AsyncPopularResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncPopularResourceWithRawResponse(self)
 
@@ -107,7 +107,7 @@ def with_streaming_response(self) -> AsyncPopularResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncPopularResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/movies/recommendations.py b/src/tmdb_client/resources/movies/recommendations.py
index 4f2ea53..88898e9 100644
--- a/src/tmdb_client/resources/movies/recommendations.py
+++ b/src/tmdb_client/resources/movies/recommendations.py
@@ -30,7 +30,7 @@ def with_raw_response(self) -> RecommendationsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return RecommendationsResourceWithRawResponse(self)
 
@@ -39,7 +39,7 @@ def with_streaming_response(self) -> RecommendationsResourceWithStreamingRespons
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return RecommendationsResourceWithStreamingResponse(self)
 
@@ -94,7 +94,7 @@ def with_raw_response(self) -> AsyncRecommendationsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncRecommendationsResourceWithRawResponse(self)
 
@@ -103,7 +103,7 @@ def with_streaming_response(self) -> AsyncRecommendationsResourceWithStreamingRe
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncRecommendationsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/movies/release_dates.py b/src/tmdb_client/resources/movies/release_dates.py
index 9cb06a6..fa197f0 100644
--- a/src/tmdb_client/resources/movies/release_dates.py
+++ b/src/tmdb_client/resources/movies/release_dates.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> ReleaseDatesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ReleaseDatesResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> ReleaseDatesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ReleaseDatesResourceWithStreamingResponse(self)
 
@@ -78,7 +78,7 @@ def with_raw_response(self) -> AsyncReleaseDatesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncReleaseDatesResourceWithRawResponse(self)
 
@@ -87,7 +87,7 @@ def with_streaming_response(self) -> AsyncReleaseDatesResourceWithStreamingRespo
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncReleaseDatesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/movies/reviews.py b/src/tmdb_client/resources/movies/reviews.py
index 4e35189..dc624e8 100644
--- a/src/tmdb_client/resources/movies/reviews.py
+++ b/src/tmdb_client/resources/movies/reviews.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> ReviewsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ReviewsResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> ReviewsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ReviewsResourceWithStreamingResponse(self)
 
@@ -95,7 +95,7 @@ def with_raw_response(self) -> AsyncReviewsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncReviewsResourceWithRawResponse(self)
 
@@ -104,7 +104,7 @@ def with_streaming_response(self) -> AsyncReviewsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncReviewsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/movies/similar.py b/src/tmdb_client/resources/movies/similar.py
index d3b7ba7..c274815 100644
--- a/src/tmdb_client/resources/movies/similar.py
+++ b/src/tmdb_client/resources/movies/similar.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> SimilarResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return SimilarResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> SimilarResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return SimilarResourceWithStreamingResponse(self)
 
@@ -95,7 +95,7 @@ def with_raw_response(self) -> AsyncSimilarResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncSimilarResourceWithRawResponse(self)
 
@@ -104,7 +104,7 @@ def with_streaming_response(self) -> AsyncSimilarResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncSimilarResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/movies/top_rated.py b/src/tmdb_client/resources/movies/top_rated.py
index 06b00e2..906b8b0 100644
--- a/src/tmdb_client/resources/movies/top_rated.py
+++ b/src/tmdb_client/resources/movies/top_rated.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> TopRatedResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return TopRatedResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> TopRatedResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return TopRatedResourceWithStreamingResponse(self)
 
@@ -98,7 +98,7 @@ def with_raw_response(self) -> AsyncTopRatedResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncTopRatedResourceWithRawResponse(self)
 
@@ -107,7 +107,7 @@ def with_streaming_response(self) -> AsyncTopRatedResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncTopRatedResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/movies/translations.py b/src/tmdb_client/resources/movies/translations.py
index 4767c1c..ecc0d39 100644
--- a/src/tmdb_client/resources/movies/translations.py
+++ b/src/tmdb_client/resources/movies/translations.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> TranslationsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return TranslationsResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> TranslationsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return TranslationsResourceWithStreamingResponse(self)
 
@@ -78,7 +78,7 @@ def with_raw_response(self) -> AsyncTranslationsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncTranslationsResourceWithRawResponse(self)
 
@@ -87,7 +87,7 @@ def with_streaming_response(self) -> AsyncTranslationsResourceWithStreamingRespo
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncTranslationsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/movies/upcoming.py b/src/tmdb_client/resources/movies/upcoming.py
index 40ea3f1..df5fe35 100644
--- a/src/tmdb_client/resources/movies/upcoming.py
+++ b/src/tmdb_client/resources/movies/upcoming.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> UpcomingResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return UpcomingResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> UpcomingResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return UpcomingResourceWithStreamingResponse(self)
 
@@ -98,7 +98,7 @@ def with_raw_response(self) -> AsyncUpcomingResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncUpcomingResourceWithRawResponse(self)
 
@@ -107,7 +107,7 @@ def with_streaming_response(self) -> AsyncUpcomingResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncUpcomingResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/movies/videos.py b/src/tmdb_client/resources/movies/videos.py
index 41ec3a1..d63cd8d 100644
--- a/src/tmdb_client/resources/movies/videos.py
+++ b/src/tmdb_client/resources/movies/videos.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> VideosResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return VideosResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> VideosResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return VideosResourceWithStreamingResponse(self)
 
@@ -88,7 +88,7 @@ def with_raw_response(self) -> AsyncVideosResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncVideosResourceWithRawResponse(self)
 
@@ -97,7 +97,7 @@ def with_streaming_response(self) -> AsyncVideosResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncVideosResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/movies/watch_providers.py b/src/tmdb_client/resources/movies/watch_providers.py
index 857ce68..cb80cb2 100644
--- a/src/tmdb_client/resources/movies/watch_providers.py
+++ b/src/tmdb_client/resources/movies/watch_providers.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> WatchProvidersResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return WatchProvidersResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> WatchProvidersResourceWithStreamingResponse
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return WatchProvidersResourceWithStreamingResponse(self)
 
@@ -78,7 +78,7 @@ def with_raw_response(self) -> AsyncWatchProvidersResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncWatchProvidersResourceWithRawResponse(self)
 
@@ -87,7 +87,7 @@ def with_streaming_response(self) -> AsyncWatchProvidersResourceWithStreamingRes
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncWatchProvidersResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/networks/alternative_names.py b/src/tmdb_client/resources/networks/alternative_names.py
index c5688d7..a966f11 100644
--- a/src/tmdb_client/resources/networks/alternative_names.py
+++ b/src/tmdb_client/resources/networks/alternative_names.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> AlternativeNamesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AlternativeNamesResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> AlternativeNamesResourceWithStreamingRespon
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AlternativeNamesResourceWithStreamingResponse(self)
 
@@ -78,7 +78,7 @@ def with_raw_response(self) -> AsyncAlternativeNamesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncAlternativeNamesResourceWithRawResponse(self)
 
@@ -87,7 +87,7 @@ def with_streaming_response(self) -> AsyncAlternativeNamesResourceWithStreamingR
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncAlternativeNamesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/networks/images.py b/src/tmdb_client/resources/networks/images.py
index 5224512..911cc3c 100644
--- a/src/tmdb_client/resources/networks/images.py
+++ b/src/tmdb_client/resources/networks/images.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> ImagesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ImagesResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> ImagesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ImagesResourceWithStreamingResponse(self)
 
@@ -78,7 +78,7 @@ def with_raw_response(self) -> AsyncImagesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncImagesResourceWithRawResponse(self)
 
@@ -87,7 +87,7 @@ def with_streaming_response(self) -> AsyncImagesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncImagesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/networks/networks.py b/src/tmdb_client/resources/networks/networks.py
index 53f3c36..bf058e6 100644
--- a/src/tmdb_client/resources/networks/networks.py
+++ b/src/tmdb_client/resources/networks/networks.py
@@ -50,7 +50,7 @@ def with_raw_response(self) -> NetworksResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return NetworksResourceWithRawResponse(self)
 
@@ -59,7 +59,7 @@ def with_streaming_response(self) -> NetworksResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return NetworksResourceWithStreamingResponse(self)
 
@@ -110,7 +110,7 @@ def with_raw_response(self) -> AsyncNetworksResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncNetworksResourceWithRawResponse(self)
 
@@ -119,7 +119,7 @@ def with_streaming_response(self) -> AsyncNetworksResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncNetworksResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/people/changes.py b/src/tmdb_client/resources/people/changes.py
index 39aaa05..285ac60 100644
--- a/src/tmdb_client/resources/people/changes.py
+++ b/src/tmdb_client/resources/people/changes.py
@@ -34,7 +34,7 @@ def with_raw_response(self) -> ChangesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ChangesResourceWithRawResponse(self)
 
@@ -43,7 +43,7 @@ def with_streaming_response(self) -> ChangesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ChangesResourceWithStreamingResponse(self)
 
@@ -99,7 +99,7 @@ def with_raw_response(self) -> AsyncChangesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncChangesResourceWithRawResponse(self)
 
@@ -108,7 +108,7 @@ def with_streaming_response(self) -> AsyncChangesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncChangesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/people/combined_credits.py b/src/tmdb_client/resources/people/combined_credits.py
index d22f415..24d4764 100644
--- a/src/tmdb_client/resources/people/combined_credits.py
+++ b/src/tmdb_client/resources/people/combined_credits.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> CombinedCreditsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return CombinedCreditsResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> CombinedCreditsResourceWithStreamingRespons
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return CombinedCreditsResourceWithStreamingResponse(self)
 
@@ -90,7 +90,7 @@ def with_raw_response(self) -> AsyncCombinedCreditsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncCombinedCreditsResourceWithRawResponse(self)
 
@@ -99,7 +99,7 @@ def with_streaming_response(self) -> AsyncCombinedCreditsResourceWithStreamingRe
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncCombinedCreditsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/people/images.py b/src/tmdb_client/resources/people/images.py
index c4f2374..df7c55e 100644
--- a/src/tmdb_client/resources/people/images.py
+++ b/src/tmdb_client/resources/people/images.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> ImagesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ImagesResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> ImagesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ImagesResourceWithStreamingResponse(self)
 
@@ -78,7 +78,7 @@ def with_raw_response(self) -> AsyncImagesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncImagesResourceWithRawResponse(self)
 
@@ -87,7 +87,7 @@ def with_streaming_response(self) -> AsyncImagesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncImagesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/people/movie_credits.py b/src/tmdb_client/resources/people/movie_credits.py
index 526b697..d23bcd9 100644
--- a/src/tmdb_client/resources/people/movie_credits.py
+++ b/src/tmdb_client/resources/people/movie_credits.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> MovieCreditsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return MovieCreditsResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> MovieCreditsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return MovieCreditsResourceWithStreamingResponse(self)
 
@@ -88,7 +88,7 @@ def with_raw_response(self) -> AsyncMovieCreditsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncMovieCreditsResourceWithRawResponse(self)
 
@@ -97,7 +97,7 @@ def with_streaming_response(self) -> AsyncMovieCreditsResourceWithStreamingRespo
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncMovieCreditsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/people/people.py b/src/tmdb_client/resources/people/people.py
index 57243d9..9c73702 100644
--- a/src/tmdb_client/resources/people/people.py
+++ b/src/tmdb_client/resources/people/people.py
@@ -107,7 +107,7 @@ def with_raw_response(self) -> PeopleResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return PeopleResourceWithRawResponse(self)
 
@@ -116,7 +116,7 @@ def with_streaming_response(self) -> PeopleResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return PeopleResourceWithStreamingResponse(self)
 
@@ -341,7 +341,7 @@ def with_raw_response(self) -> AsyncPeopleResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncPeopleResourceWithRawResponse(self)
 
@@ -350,7 +350,7 @@ def with_streaming_response(self) -> AsyncPeopleResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncPeopleResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/people/popular.py b/src/tmdb_client/resources/people/popular.py
index 8ed5649..650993a 100644
--- a/src/tmdb_client/resources/people/popular.py
+++ b/src/tmdb_client/resources/people/popular.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> PopularResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return PopularResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> PopularResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return PopularResourceWithStreamingResponse(self)
 
@@ -94,7 +94,7 @@ def with_raw_response(self) -> AsyncPopularResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncPopularResourceWithRawResponse(self)
 
@@ -103,7 +103,7 @@ def with_streaming_response(self) -> AsyncPopularResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncPopularResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/people/tv_credits.py b/src/tmdb_client/resources/people/tv_credits.py
index 08ecb13..1fcc231 100644
--- a/src/tmdb_client/resources/people/tv_credits.py
+++ b/src/tmdb_client/resources/people/tv_credits.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> TvCreditsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return TvCreditsResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> TvCreditsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return TvCreditsResourceWithStreamingResponse(self)
 
@@ -88,7 +88,7 @@ def with_raw_response(self) -> AsyncTvCreditsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncTvCreditsResourceWithRawResponse(self)
 
@@ -97,7 +97,7 @@ def with_streaming_response(self) -> AsyncTvCreditsResourceWithStreamingResponse
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncTvCreditsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/person/latest.py b/src/tmdb_client/resources/person/latest.py
index a693570..e9499d3 100644
--- a/src/tmdb_client/resources/person/latest.py
+++ b/src/tmdb_client/resources/person/latest.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> LatestResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return LatestResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> LatestResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return LatestResourceWithStreamingResponse(self)
 
@@ -70,7 +70,7 @@ def with_raw_response(self) -> AsyncLatestResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncLatestResourceWithRawResponse(self)
 
@@ -79,7 +79,7 @@ def with_streaming_response(self) -> AsyncLatestResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncLatestResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/person/person.py b/src/tmdb_client/resources/person/person.py
index 76a2938..9344a82 100644
--- a/src/tmdb_client/resources/person/person.py
+++ b/src/tmdb_client/resources/person/person.py
@@ -27,7 +27,7 @@ def with_raw_response(self) -> PersonResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return PersonResourceWithRawResponse(self)
 
@@ -36,7 +36,7 @@ def with_streaming_response(self) -> PersonResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return PersonResourceWithStreamingResponse(self)
 
@@ -52,7 +52,7 @@ def with_raw_response(self) -> AsyncPersonResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncPersonResourceWithRawResponse(self)
 
@@ -61,7 +61,7 @@ def with_streaming_response(self) -> AsyncPersonResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncPersonResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/reviews.py b/src/tmdb_client/resources/reviews.py
index 7c38f27..ec56fb7 100644
--- a/src/tmdb_client/resources/reviews.py
+++ b/src/tmdb_client/resources/reviews.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> ReviewsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ReviewsResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> ReviewsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ReviewsResourceWithStreamingResponse(self)
 
@@ -80,7 +80,7 @@ def with_raw_response(self) -> AsyncReviewsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncReviewsResourceWithRawResponse(self)
 
@@ -89,7 +89,7 @@ def with_streaming_response(self) -> AsyncReviewsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncReviewsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/search.py b/src/tmdb_client/resources/search.py
index bbd9498..e319857 100644
--- a/src/tmdb_client/resources/search.py
+++ b/src/tmdb_client/resources/search.py
@@ -33,7 +33,7 @@ def with_raw_response(self) -> SearchResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return SearchResourceWithRawResponse(self)
 
@@ -42,7 +42,7 @@ def with_streaming_response(self) -> SearchResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return SearchResourceWithStreamingResponse(self)
 
@@ -191,7 +191,7 @@ def with_raw_response(self) -> AsyncSearchResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncSearchResourceWithRawResponse(self)
 
@@ -200,7 +200,7 @@ def with_streaming_response(self) -> AsyncSearchResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncSearchResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/trending.py b/src/tmdb_client/resources/trending.py
index 5ba9421..bf85852 100644
--- a/src/tmdb_client/resources/trending.py
+++ b/src/tmdb_client/resources/trending.py
@@ -33,7 +33,7 @@ def with_raw_response(self) -> TrendingResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return TrendingResourceWithRawResponse(self)
 
@@ -42,7 +42,7 @@ def with_streaming_response(self) -> TrendingResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return TrendingResourceWithStreamingResponse(self)
 
@@ -94,7 +94,7 @@ def with_raw_response(self) -> AsyncTrendingResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncTrendingResourceWithRawResponse(self)
 
@@ -103,7 +103,7 @@ def with_streaming_response(self) -> AsyncTrendingResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncTrendingResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/trending_movies.py b/src/tmdb_client/resources/trending_movies.py
index f3593b4..c8ab7ef 100644
--- a/src/tmdb_client/resources/trending_movies.py
+++ b/src/tmdb_client/resources/trending_movies.py
@@ -33,7 +33,7 @@ def with_raw_response(self) -> TrendingMoviesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return TrendingMoviesResourceWithRawResponse(self)
 
@@ -42,7 +42,7 @@ def with_streaming_response(self) -> TrendingMoviesResourceWithStreamingResponse
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return TrendingMoviesResourceWithStreamingResponse(self)
 
@@ -94,7 +94,7 @@ def with_raw_response(self) -> AsyncTrendingMoviesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncTrendingMoviesResourceWithRawResponse(self)
 
@@ -103,7 +103,7 @@ def with_streaming_response(self) -> AsyncTrendingMoviesResourceWithStreamingRes
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncTrendingMoviesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/trending_people.py b/src/tmdb_client/resources/trending_people.py
index b9cbfa6..1fbcb97 100644
--- a/src/tmdb_client/resources/trending_people.py
+++ b/src/tmdb_client/resources/trending_people.py
@@ -33,7 +33,7 @@ def with_raw_response(self) -> TrendingPeopleResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return TrendingPeopleResourceWithRawResponse(self)
 
@@ -42,7 +42,7 @@ def with_streaming_response(self) -> TrendingPeopleResourceWithStreamingResponse
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return TrendingPeopleResourceWithStreamingResponse(self)
 
@@ -94,7 +94,7 @@ def with_raw_response(self) -> AsyncTrendingPeopleResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncTrendingPeopleResourceWithRawResponse(self)
 
@@ -103,7 +103,7 @@ def with_streaming_response(self) -> AsyncTrendingPeopleResourceWithStreamingRes
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncTrendingPeopleResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/trending_tv_shows.py b/src/tmdb_client/resources/trending_tv_shows.py
index 8221b25..5977b45 100644
--- a/src/tmdb_client/resources/trending_tv_shows.py
+++ b/src/tmdb_client/resources/trending_tv_shows.py
@@ -33,7 +33,7 @@ def with_raw_response(self) -> TrendingTvShowsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return TrendingTvShowsResourceWithRawResponse(self)
 
@@ -42,7 +42,7 @@ def with_streaming_response(self) -> TrendingTvShowsResourceWithStreamingRespons
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return TrendingTvShowsResourceWithStreamingResponse(self)
 
@@ -94,7 +94,7 @@ def with_raw_response(self) -> AsyncTrendingTvShowsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncTrendingTvShowsResourceWithRawResponse(self)
 
@@ -103,7 +103,7 @@ def with_streaming_response(self) -> AsyncTrendingTvShowsResourceWithStreamingRe
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncTrendingTvShowsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv/account_states.py b/src/tmdb_client/resources/tv/account_states.py
index 482589e..3de5b73 100644
--- a/src/tmdb_client/resources/tv/account_states.py
+++ b/src/tmdb_client/resources/tv/account_states.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> AccountStatesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AccountStatesResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> AccountStatesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AccountStatesResourceWithStreamingResponse(self)
 
@@ -95,7 +95,7 @@ def with_raw_response(self) -> AsyncAccountStatesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncAccountStatesResourceWithRawResponse(self)
 
@@ -104,7 +104,7 @@ def with_streaming_response(self) -> AsyncAccountStatesResourceWithStreamingResp
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncAccountStatesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv/changes.py b/src/tmdb_client/resources/tv/changes.py
index 8be079e..c1dfedd 100644
--- a/src/tmdb_client/resources/tv/changes.py
+++ b/src/tmdb_client/resources/tv/changes.py
@@ -34,7 +34,7 @@ def with_raw_response(self) -> ChangesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ChangesResourceWithRawResponse(self)
 
@@ -43,7 +43,7 @@ def with_streaming_response(self) -> ChangesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ChangesResourceWithStreamingResponse(self)
 
@@ -99,7 +99,7 @@ def with_raw_response(self) -> AsyncChangesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncChangesResourceWithRawResponse(self)
 
@@ -108,7 +108,7 @@ def with_streaming_response(self) -> AsyncChangesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncChangesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv/episode/changes.py b/src/tmdb_client/resources/tv/episode/changes.py
index b3b9aa2..340af18 100644
--- a/src/tmdb_client/resources/tv/episode/changes.py
+++ b/src/tmdb_client/resources/tv/episode/changes.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> ChangesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ChangesResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> ChangesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ChangesResourceWithStreamingResponse(self)
 
@@ -78,7 +78,7 @@ def with_raw_response(self) -> AsyncChangesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncChangesResourceWithRawResponse(self)
 
@@ -87,7 +87,7 @@ def with_streaming_response(self) -> AsyncChangesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncChangesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv/episode/episode.py b/src/tmdb_client/resources/tv/episode/episode.py
index 9a5c989..de2f374 100644
--- a/src/tmdb_client/resources/tv/episode/episode.py
+++ b/src/tmdb_client/resources/tv/episode/episode.py
@@ -27,7 +27,7 @@ def with_raw_response(self) -> EpisodeResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return EpisodeResourceWithRawResponse(self)
 
@@ -36,7 +36,7 @@ def with_streaming_response(self) -> EpisodeResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return EpisodeResourceWithStreamingResponse(self)
 
@@ -52,7 +52,7 @@ def with_raw_response(self) -> AsyncEpisodeResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncEpisodeResourceWithRawResponse(self)
 
@@ -61,7 +61,7 @@ def with_streaming_response(self) -> AsyncEpisodeResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncEpisodeResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv/episode_group.py b/src/tmdb_client/resources/tv/episode_group.py
index 45c2c6e..cbe693e 100644
--- a/src/tmdb_client/resources/tv/episode_group.py
+++ b/src/tmdb_client/resources/tv/episode_group.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> EpisodeGroupResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return EpisodeGroupResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> EpisodeGroupResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return EpisodeGroupResourceWithStreamingResponse(self)
 
@@ -82,7 +82,7 @@ def with_raw_response(self) -> AsyncEpisodeGroupResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncEpisodeGroupResourceWithRawResponse(self)
 
@@ -91,7 +91,7 @@ def with_streaming_response(self) -> AsyncEpisodeGroupResourceWithStreamingRespo
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncEpisodeGroupResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv/episodes/episodes.py b/src/tmdb_client/resources/tv/episodes/episodes.py
index 3160f57..774b050 100644
--- a/src/tmdb_client/resources/tv/episodes/episodes.py
+++ b/src/tmdb_client/resources/tv/episodes/episodes.py
@@ -39,7 +39,7 @@ def with_raw_response(self) -> EpisodesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return EpisodesResourceWithRawResponse(self)
 
@@ -48,7 +48,7 @@ def with_streaming_response(self) -> EpisodesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return EpisodesResourceWithStreamingResponse(self)
 
@@ -68,7 +68,7 @@ def with_raw_response(self) -> AsyncEpisodesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncEpisodesResourceWithRawResponse(self)
 
@@ -77,7 +77,7 @@ def with_streaming_response(self) -> AsyncEpisodesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncEpisodesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv/episodes/rating.py b/src/tmdb_client/resources/tv/episodes/rating.py
index 1f0985d..4490ccc 100644
--- a/src/tmdb_client/resources/tv/episodes/rating.py
+++ b/src/tmdb_client/resources/tv/episodes/rating.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> RatingResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return RatingResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> RatingResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return RatingResourceWithStreamingResponse(self)
 
@@ -97,7 +97,7 @@ def with_raw_response(self) -> AsyncRatingResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncRatingResourceWithRawResponse(self)
 
@@ -106,7 +106,7 @@ def with_streaming_response(self) -> AsyncRatingResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncRatingResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv/episodes/videos.py b/src/tmdb_client/resources/tv/episodes/videos.py
index 0c3d09d..bea668d 100644
--- a/src/tmdb_client/resources/tv/episodes/videos.py
+++ b/src/tmdb_client/resources/tv/episodes/videos.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> VideosResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return VideosResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> VideosResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return VideosResourceWithStreamingResponse(self)
 
@@ -100,7 +100,7 @@ def with_raw_response(self) -> AsyncVideosResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncVideosResourceWithRawResponse(self)
 
@@ -109,7 +109,7 @@ def with_streaming_response(self) -> AsyncVideosResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncVideosResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv/images.py b/src/tmdb_client/resources/tv/images.py
index 7da2a0b..1245c94 100644
--- a/src/tmdb_client/resources/tv/images.py
+++ b/src/tmdb_client/resources/tv/images.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> ImagesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ImagesResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> ImagesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ImagesResourceWithStreamingResponse(self)
 
@@ -99,7 +99,7 @@ def with_raw_response(self) -> AsyncImagesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncImagesResourceWithRawResponse(self)
 
@@ -108,7 +108,7 @@ def with_streaming_response(self) -> AsyncImagesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncImagesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv/seasons/account_states.py b/src/tmdb_client/resources/tv/seasons/account_states.py
index c3ee8f0..321377b 100644
--- a/src/tmdb_client/resources/tv/seasons/account_states.py
+++ b/src/tmdb_client/resources/tv/seasons/account_states.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> AccountStatesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AccountStatesResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> AccountStatesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AccountStatesResourceWithStreamingResponse(self)
 
@@ -96,7 +96,7 @@ def with_raw_response(self) -> AsyncAccountStatesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncAccountStatesResourceWithRawResponse(self)
 
@@ -105,7 +105,7 @@ def with_streaming_response(self) -> AsyncAccountStatesResourceWithStreamingResp
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncAccountStatesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv/seasons/aggregate_credits.py b/src/tmdb_client/resources/tv/seasons/aggregate_credits.py
index a35a177..0beaf66 100644
--- a/src/tmdb_client/resources/tv/seasons/aggregate_credits.py
+++ b/src/tmdb_client/resources/tv/seasons/aggregate_credits.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> AggregateCreditsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AggregateCreditsResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> AggregateCreditsResourceWithStreamingRespon
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AggregateCreditsResourceWithStreamingResponse(self)
 
@@ -91,7 +91,7 @@ def with_raw_response(self) -> AsyncAggregateCreditsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncAggregateCreditsResourceWithRawResponse(self)
 
@@ -100,7 +100,7 @@ def with_streaming_response(self) -> AsyncAggregateCreditsResourceWithStreamingR
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncAggregateCreditsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv/seasons/changes.py b/src/tmdb_client/resources/tv/seasons/changes.py
index daf5f26..859f133 100644
--- a/src/tmdb_client/resources/tv/seasons/changes.py
+++ b/src/tmdb_client/resources/tv/seasons/changes.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> ChangesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ChangesResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> ChangesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ChangesResourceWithStreamingResponse(self)
 
@@ -97,7 +97,7 @@ def with_raw_response(self) -> AsyncChangesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncChangesResourceWithRawResponse(self)
 
@@ -106,7 +106,7 @@ def with_streaming_response(self) -> AsyncChangesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncChangesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv/seasons/credits.py b/src/tmdb_client/resources/tv/seasons/credits.py
index 40363fe..b63f0c8 100644
--- a/src/tmdb_client/resources/tv/seasons/credits.py
+++ b/src/tmdb_client/resources/tv/seasons/credits.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> CreditsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return CreditsResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> CreditsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return CreditsResourceWithStreamingResponse(self)
 
@@ -89,7 +89,7 @@ def with_raw_response(self) -> AsyncCreditsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncCreditsResourceWithRawResponse(self)
 
@@ -98,7 +98,7 @@ def with_streaming_response(self) -> AsyncCreditsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncCreditsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv/seasons/episodes/credits.py b/src/tmdb_client/resources/tv/seasons/episodes/credits.py
index 58ba4ad..2c5f230 100644
--- a/src/tmdb_client/resources/tv/seasons/episodes/credits.py
+++ b/src/tmdb_client/resources/tv/seasons/episodes/credits.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> CreditsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return CreditsResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> CreditsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return CreditsResourceWithStreamingResponse(self)
 
@@ -90,7 +90,7 @@ def with_raw_response(self) -> AsyncCreditsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncCreditsResourceWithRawResponse(self)
 
@@ -99,7 +99,7 @@ def with_streaming_response(self) -> AsyncCreditsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncCreditsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv/seasons/episodes/episodes.py b/src/tmdb_client/resources/tv/seasons/episodes/episodes.py
index 5124ee4..8d6da78 100644
--- a/src/tmdb_client/resources/tv/seasons/episodes/episodes.py
+++ b/src/tmdb_client/resources/tv/seasons/episodes/episodes.py
@@ -79,7 +79,7 @@ def with_raw_response(self) -> EpisodesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return EpisodesResourceWithRawResponse(self)
 
@@ -88,7 +88,7 @@ def with_streaming_response(self) -> EpisodesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return EpisodesResourceWithStreamingResponse(self)
 
@@ -163,7 +163,7 @@ def with_raw_response(self) -> AsyncEpisodesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncEpisodesResourceWithRawResponse(self)
 
@@ -172,7 +172,7 @@ def with_streaming_response(self) -> AsyncEpisodesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncEpisodesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv/seasons/episodes/external_ids.py b/src/tmdb_client/resources/tv/seasons/episodes/external_ids.py
index f16a26d..fefd013 100644
--- a/src/tmdb_client/resources/tv/seasons/episodes/external_ids.py
+++ b/src/tmdb_client/resources/tv/seasons/episodes/external_ids.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> ExternalIDsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ExternalIDsResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> ExternalIDsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ExternalIDsResourceWithStreamingResponse(self)
 
@@ -82,7 +82,7 @@ def with_raw_response(self) -> AsyncExternalIDsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncExternalIDsResourceWithRawResponse(self)
 
@@ -91,7 +91,7 @@ def with_streaming_response(self) -> AsyncExternalIDsResourceWithStreamingRespon
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncExternalIDsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv/seasons/episodes/images.py b/src/tmdb_client/resources/tv/seasons/episodes/images.py
index 11302d7..00ca192 100644
--- a/src/tmdb_client/resources/tv/seasons/episodes/images.py
+++ b/src/tmdb_client/resources/tv/seasons/episodes/images.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> ImagesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ImagesResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> ImagesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ImagesResourceWithStreamingResponse(self)
 
@@ -101,7 +101,7 @@ def with_raw_response(self) -> AsyncImagesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncImagesResourceWithRawResponse(self)
 
@@ -110,7 +110,7 @@ def with_streaming_response(self) -> AsyncImagesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncImagesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv/seasons/episodes/translations.py b/src/tmdb_client/resources/tv/seasons/episodes/translations.py
index feaeff6..8e9c765 100644
--- a/src/tmdb_client/resources/tv/seasons/episodes/translations.py
+++ b/src/tmdb_client/resources/tv/seasons/episodes/translations.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> TranslationsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return TranslationsResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> TranslationsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return TranslationsResourceWithStreamingResponse(self)
 
@@ -80,7 +80,7 @@ def with_raw_response(self) -> AsyncTranslationsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncTranslationsResourceWithRawResponse(self)
 
@@ -89,7 +89,7 @@ def with_streaming_response(self) -> AsyncTranslationsResourceWithStreamingRespo
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncTranslationsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv/seasons/external_ids.py b/src/tmdb_client/resources/tv/seasons/external_ids.py
index edb6853..5364ad8 100644
--- a/src/tmdb_client/resources/tv/seasons/external_ids.py
+++ b/src/tmdb_client/resources/tv/seasons/external_ids.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> ExternalIDsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ExternalIDsResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> ExternalIDsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ExternalIDsResourceWithStreamingResponse(self)
 
@@ -79,7 +79,7 @@ def with_raw_response(self) -> AsyncExternalIDsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncExternalIDsResourceWithRawResponse(self)
 
@@ -88,7 +88,7 @@ def with_streaming_response(self) -> AsyncExternalIDsResourceWithStreamingRespon
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncExternalIDsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv/seasons/images.py b/src/tmdb_client/resources/tv/seasons/images.py
index 4cb5356..18c4e83 100644
--- a/src/tmdb_client/resources/tv/seasons/images.py
+++ b/src/tmdb_client/resources/tv/seasons/images.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> ImagesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ImagesResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> ImagesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ImagesResourceWithStreamingResponse(self)
 
@@ -100,7 +100,7 @@ def with_raw_response(self) -> AsyncImagesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncImagesResourceWithRawResponse(self)
 
@@ -109,7 +109,7 @@ def with_streaming_response(self) -> AsyncImagesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncImagesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv/seasons/seasons.py b/src/tmdb_client/resources/tv/seasons/seasons.py
index ecc43a0..6e54e49 100644
--- a/src/tmdb_client/resources/tv/seasons/seasons.py
+++ b/src/tmdb_client/resources/tv/seasons/seasons.py
@@ -36,14 +36,6 @@
     CreditsResourceWithStreamingResponse,
     AsyncCreditsResourceWithStreamingResponse,
 )
-from .episodes import (
-    EpisodesResource,
-    AsyncEpisodesResource,
-    EpisodesResourceWithRawResponse,
-    AsyncEpisodesResourceWithRawResponse,
-    EpisodesResourceWithStreamingResponse,
-    AsyncEpisodesResourceWithStreamingResponse,
-)
 from ...._types import NOT_GIVEN, Body, Query, Headers, NotGiven
 from ...._utils import (
     maybe_transform,
@@ -99,7 +91,14 @@
     AggregateCreditsResourceWithStreamingResponse,
     AsyncAggregateCreditsResourceWithStreamingResponse,
 )
-from .episodes.episodes import EpisodesResource, AsyncEpisodesResource
+from .episodes.episodes import (
+    EpisodesResource,
+    AsyncEpisodesResource,
+    EpisodesResourceWithRawResponse,
+    AsyncEpisodesResourceWithRawResponse,
+    EpisodesResourceWithStreamingResponse,
+    AsyncEpisodesResourceWithStreamingResponse,
+)
 from ....types.tv.season_retrieve_response import SeasonRetrieveResponse
 
 __all__ = ["SeasonsResource", "AsyncSeasonsResource"]
@@ -152,7 +151,7 @@ def with_raw_response(self) -> SeasonsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return SeasonsResourceWithRawResponse(self)
 
@@ -161,7 +160,7 @@ def with_streaming_response(self) -> SeasonsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return SeasonsResourceWithStreamingResponse(self)
 
@@ -259,7 +258,7 @@ def with_raw_response(self) -> AsyncSeasonsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncSeasonsResourceWithRawResponse(self)
 
@@ -268,7 +267,7 @@ def with_streaming_response(self) -> AsyncSeasonsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncSeasonsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv/seasons/translations.py b/src/tmdb_client/resources/tv/seasons/translations.py
index 92e73da..677a65d 100644
--- a/src/tmdb_client/resources/tv/seasons/translations.py
+++ b/src/tmdb_client/resources/tv/seasons/translations.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> TranslationsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return TranslationsResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> TranslationsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return TranslationsResourceWithStreamingResponse(self)
 
@@ -79,7 +79,7 @@ def with_raw_response(self) -> AsyncTranslationsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncTranslationsResourceWithRawResponse(self)
 
@@ -88,7 +88,7 @@ def with_streaming_response(self) -> AsyncTranslationsResourceWithStreamingRespo
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncTranslationsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv/seasons/videos.py b/src/tmdb_client/resources/tv/seasons/videos.py
index 57d3281..ec50bb9 100644
--- a/src/tmdb_client/resources/tv/seasons/videos.py
+++ b/src/tmdb_client/resources/tv/seasons/videos.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> VideosResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return VideosResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> VideosResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return VideosResourceWithStreamingResponse(self)
 
@@ -99,7 +99,7 @@ def with_raw_response(self) -> AsyncVideosResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncVideosResourceWithRawResponse(self)
 
@@ -108,7 +108,7 @@ def with_streaming_response(self) -> AsyncVideosResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncVideosResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv/seasons/watch_providers.py b/src/tmdb_client/resources/tv/seasons/watch_providers.py
index 59de0ea..a866098 100644
--- a/src/tmdb_client/resources/tv/seasons/watch_providers.py
+++ b/src/tmdb_client/resources/tv/seasons/watch_providers.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> WatchProvidersResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return WatchProvidersResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> WatchProvidersResourceWithStreamingResponse
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return WatchProvidersResourceWithStreamingResponse(self)
 
@@ -89,7 +89,7 @@ def with_raw_response(self) -> AsyncWatchProvidersResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncWatchProvidersResourceWithRawResponse(self)
 
@@ -98,7 +98,7 @@ def with_streaming_response(self) -> AsyncWatchProvidersResourceWithStreamingRes
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncWatchProvidersResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv/tv.py b/src/tmdb_client/resources/tv/tv.py
index 016aa9f..0ec67ec 100644
--- a/src/tmdb_client/resources/tv/tv.py
+++ b/src/tmdb_client/resources/tv/tv.py
@@ -21,35 +21,11 @@
     ChangesResourceWithStreamingResponse,
     AsyncChangesResourceWithStreamingResponse,
 )
-from .episode import (
-    EpisodeResource,
-    AsyncEpisodeResource,
-    EpisodeResourceWithRawResponse,
-    AsyncEpisodeResourceWithRawResponse,
-    EpisodeResourceWithStreamingResponse,
-    AsyncEpisodeResourceWithStreamingResponse,
-)
-from .seasons import (
-    SeasonsResource,
-    AsyncSeasonsResource,
-    SeasonsResourceWithRawResponse,
-    AsyncSeasonsResourceWithRawResponse,
-    SeasonsResourceWithStreamingResponse,
-    AsyncSeasonsResourceWithStreamingResponse,
-)
 from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
 from ..._utils import (
     maybe_transform,
     async_maybe_transform,
 )
-from .episodes import (
-    EpisodesResource,
-    AsyncEpisodesResource,
-    EpisodesResourceWithRawResponse,
-    AsyncEpisodesResourceWithRawResponse,
-    EpisodesResourceWithStreamingResponse,
-    AsyncEpisodesResourceWithStreamingResponse,
-)
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
 from ..._response import (
@@ -75,9 +51,30 @@
     AccountStatesResourceWithStreamingResponse,
     AsyncAccountStatesResourceWithStreamingResponse,
 )
-from .episode.episode import EpisodeResource, AsyncEpisodeResource
-from .seasons.seasons import SeasonsResource, AsyncSeasonsResource
-from .episodes.episodes import EpisodesResource, AsyncEpisodesResource
+from .episode.episode import (
+    EpisodeResource,
+    AsyncEpisodeResource,
+    EpisodeResourceWithRawResponse,
+    AsyncEpisodeResourceWithRawResponse,
+    EpisodeResourceWithStreamingResponse,
+    AsyncEpisodeResourceWithStreamingResponse,
+)
+from .seasons.seasons import (
+    SeasonsResource,
+    AsyncSeasonsResource,
+    SeasonsResourceWithRawResponse,
+    AsyncSeasonsResourceWithRawResponse,
+    SeasonsResourceWithStreamingResponse,
+    AsyncSeasonsResourceWithStreamingResponse,
+)
+from .episodes.episodes import (
+    EpisodesResource,
+    AsyncEpisodesResource,
+    EpisodesResourceWithRawResponse,
+    AsyncEpisodesResourceWithRawResponse,
+    EpisodesResourceWithStreamingResponse,
+    AsyncEpisodesResourceWithStreamingResponse,
+)
 from ...types.tv_search_response import TvSearchResponse
 from ...types.tv_retrieve_response import TvRetrieveResponse
 
@@ -119,7 +116,7 @@ def with_raw_response(self) -> TvResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return TvResourceWithRawResponse(self)
 
@@ -128,7 +125,7 @@ def with_streaming_response(self) -> TvResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return TvResourceWithStreamingResponse(self)
 
@@ -269,7 +266,7 @@ def with_raw_response(self) -> AsyncTvResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncTvResourceWithRawResponse(self)
 
@@ -278,7 +275,7 @@ def with_streaming_response(self) -> AsyncTvResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncTvResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv_series.py b/src/tmdb_client/resources/tv_series.py
index 47afc87..6333569 100644
--- a/src/tmdb_client/resources/tv_series.py
+++ b/src/tmdb_client/resources/tv_series.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> TvSeriesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return TvSeriesResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> TvSeriesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return TvSeriesResourceWithStreamingResponse(self)
 
@@ -95,7 +95,7 @@ def with_raw_response(self) -> AsyncTvSeriesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncTvSeriesResourceWithRawResponse(self)
 
@@ -104,7 +104,7 @@ def with_streaming_response(self) -> AsyncTvSeriesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncTvSeriesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv_shows/aggregate_credits.py b/src/tmdb_client/resources/tv_shows/aggregate_credits.py
index f1f8266..108fa0a 100644
--- a/src/tmdb_client/resources/tv_shows/aggregate_credits.py
+++ b/src/tmdb_client/resources/tv_shows/aggregate_credits.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> AggregateCreditsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AggregateCreditsResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> AggregateCreditsResourceWithStreamingRespon
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AggregateCreditsResourceWithStreamingResponse(self)
 
@@ -90,7 +90,7 @@ def with_raw_response(self) -> AsyncAggregateCreditsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncAggregateCreditsResourceWithRawResponse(self)
 
@@ -99,7 +99,7 @@ def with_streaming_response(self) -> AsyncAggregateCreditsResourceWithStreamingR
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncAggregateCreditsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv_shows/airing_today.py b/src/tmdb_client/resources/tv_shows/airing_today.py
index 7c28eb5..9b3b109 100644
--- a/src/tmdb_client/resources/tv_shows/airing_today.py
+++ b/src/tmdb_client/resources/tv_shows/airing_today.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> AiringTodayResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AiringTodayResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> AiringTodayResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AiringTodayResourceWithStreamingResponse(self)
 
@@ -96,7 +96,7 @@ def with_raw_response(self) -> AsyncAiringTodayResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncAiringTodayResourceWithRawResponse(self)
 
@@ -105,7 +105,7 @@ def with_streaming_response(self) -> AsyncAiringTodayResourceWithStreamingRespon
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncAiringTodayResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv_shows/alternative_titles.py b/src/tmdb_client/resources/tv_shows/alternative_titles.py
index a43ecf4..751ae96 100644
--- a/src/tmdb_client/resources/tv_shows/alternative_titles.py
+++ b/src/tmdb_client/resources/tv_shows/alternative_titles.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> AlternativeTitlesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AlternativeTitlesResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> AlternativeTitlesResourceWithStreamingRespo
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AlternativeTitlesResourceWithStreamingResponse(self)
 
@@ -78,7 +78,7 @@ def with_raw_response(self) -> AsyncAlternativeTitlesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncAlternativeTitlesResourceWithRawResponse(self)
 
@@ -87,7 +87,7 @@ def with_streaming_response(self) -> AsyncAlternativeTitlesResourceWithStreaming
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncAlternativeTitlesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv_shows/changes.py b/src/tmdb_client/resources/tv_shows/changes.py
index 0f23c1b..f23a24f 100644
--- a/src/tmdb_client/resources/tv_shows/changes.py
+++ b/src/tmdb_client/resources/tv_shows/changes.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> ChangesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ChangesResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> ChangesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ChangesResourceWithStreamingResponse(self)
 
@@ -97,7 +97,7 @@ def with_raw_response(self) -> AsyncChangesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncChangesResourceWithRawResponse(self)
 
@@ -106,7 +106,7 @@ def with_streaming_response(self) -> AsyncChangesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncChangesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv_shows/content_ratings.py b/src/tmdb_client/resources/tv_shows/content_ratings.py
index cdaaa36..b04f067 100644
--- a/src/tmdb_client/resources/tv_shows/content_ratings.py
+++ b/src/tmdb_client/resources/tv_shows/content_ratings.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> ContentRatingsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ContentRatingsResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> ContentRatingsResourceWithStreamingResponse
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ContentRatingsResourceWithStreamingResponse(self)
 
@@ -78,7 +78,7 @@ def with_raw_response(self) -> AsyncContentRatingsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncContentRatingsResourceWithRawResponse(self)
 
@@ -87,7 +87,7 @@ def with_streaming_response(self) -> AsyncContentRatingsResourceWithStreamingRes
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncContentRatingsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv_shows/credits.py b/src/tmdb_client/resources/tv_shows/credits.py
index 4d0eaf7..027ae00 100644
--- a/src/tmdb_client/resources/tv_shows/credits.py
+++ b/src/tmdb_client/resources/tv_shows/credits.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> CreditsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return CreditsResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> CreditsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return CreditsResourceWithStreamingResponse(self)
 
@@ -88,7 +88,7 @@ def with_raw_response(self) -> AsyncCreditsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncCreditsResourceWithRawResponse(self)
 
@@ -97,7 +97,7 @@ def with_streaming_response(self) -> AsyncCreditsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncCreditsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv_shows/episode_groups.py b/src/tmdb_client/resources/tv_shows/episode_groups.py
index 9cf4c76..a0c8ac4 100644
--- a/src/tmdb_client/resources/tv_shows/episode_groups.py
+++ b/src/tmdb_client/resources/tv_shows/episode_groups.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> EpisodeGroupsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return EpisodeGroupsResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> EpisodeGroupsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return EpisodeGroupsResourceWithStreamingResponse(self)
 
@@ -78,7 +78,7 @@ def with_raw_response(self) -> AsyncEpisodeGroupsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncEpisodeGroupsResourceWithRawResponse(self)
 
@@ -87,7 +87,7 @@ def with_streaming_response(self) -> AsyncEpisodeGroupsResourceWithStreamingResp
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncEpisodeGroupsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv_shows/external_ids.py b/src/tmdb_client/resources/tv_shows/external_ids.py
index b879a25..e1a892b 100644
--- a/src/tmdb_client/resources/tv_shows/external_ids.py
+++ b/src/tmdb_client/resources/tv_shows/external_ids.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> ExternalIDsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ExternalIDsResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> ExternalIDsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ExternalIDsResourceWithStreamingResponse(self)
 
@@ -78,7 +78,7 @@ def with_raw_response(self) -> AsyncExternalIDsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncExternalIDsResourceWithRawResponse(self)
 
@@ -87,7 +87,7 @@ def with_streaming_response(self) -> AsyncExternalIDsResourceWithStreamingRespon
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncExternalIDsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv_shows/keywords.py b/src/tmdb_client/resources/tv_shows/keywords.py
index 94c795b..62a93c7 100644
--- a/src/tmdb_client/resources/tv_shows/keywords.py
+++ b/src/tmdb_client/resources/tv_shows/keywords.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> KeywordsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return KeywordsResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> KeywordsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return KeywordsResourceWithStreamingResponse(self)
 
@@ -78,7 +78,7 @@ def with_raw_response(self) -> AsyncKeywordsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncKeywordsResourceWithRawResponse(self)
 
@@ -87,7 +87,7 @@ def with_streaming_response(self) -> AsyncKeywordsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncKeywordsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv_shows/latest.py b/src/tmdb_client/resources/tv_shows/latest.py
index b536c4b..7e8f00c 100644
--- a/src/tmdb_client/resources/tv_shows/latest.py
+++ b/src/tmdb_client/resources/tv_shows/latest.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> LatestResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return LatestResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> LatestResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return LatestResourceWithStreamingResponse(self)
 
@@ -66,7 +66,7 @@ def with_raw_response(self) -> AsyncLatestResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncLatestResourceWithRawResponse(self)
 
@@ -75,7 +75,7 @@ def with_streaming_response(self) -> AsyncLatestResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncLatestResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv_shows/on_the_air.py b/src/tmdb_client/resources/tv_shows/on_the_air.py
index 5c2a98e..4263ff8 100644
--- a/src/tmdb_client/resources/tv_shows/on_the_air.py
+++ b/src/tmdb_client/resources/tv_shows/on_the_air.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> OnTheAirResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return OnTheAirResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> OnTheAirResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return OnTheAirResourceWithStreamingResponse(self)
 
@@ -96,7 +96,7 @@ def with_raw_response(self) -> AsyncOnTheAirResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncOnTheAirResourceWithRawResponse(self)
 
@@ -105,7 +105,7 @@ def with_streaming_response(self) -> AsyncOnTheAirResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncOnTheAirResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv_shows/popular.py b/src/tmdb_client/resources/tv_shows/popular.py
index 0d85e1f..7146cda 100644
--- a/src/tmdb_client/resources/tv_shows/popular.py
+++ b/src/tmdb_client/resources/tv_shows/popular.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> PopularResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return PopularResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> PopularResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return PopularResourceWithStreamingResponse(self)
 
@@ -94,7 +94,7 @@ def with_raw_response(self) -> AsyncPopularResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncPopularResourceWithRawResponse(self)
 
@@ -103,7 +103,7 @@ def with_streaming_response(self) -> AsyncPopularResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncPopularResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv_shows/rating.py b/src/tmdb_client/resources/tv_shows/rating.py
index 102af63..13cd56a 100644
--- a/src/tmdb_client/resources/tv_shows/rating.py
+++ b/src/tmdb_client/resources/tv_shows/rating.py
@@ -32,7 +32,7 @@ def with_raw_response(self) -> RatingResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return RatingResourceWithRawResponse(self)
 
@@ -41,7 +41,7 @@ def with_streaming_response(self) -> RatingResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return RatingResourceWithStreamingResponse(self)
 
@@ -141,7 +141,7 @@ def with_raw_response(self) -> AsyncRatingResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncRatingResourceWithRawResponse(self)
 
@@ -150,7 +150,7 @@ def with_streaming_response(self) -> AsyncRatingResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncRatingResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv_shows/recommendations.py b/src/tmdb_client/resources/tv_shows/recommendations.py
index 2499073..a6ff178 100644
--- a/src/tmdb_client/resources/tv_shows/recommendations.py
+++ b/src/tmdb_client/resources/tv_shows/recommendations.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> RecommendationsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return RecommendationsResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> RecommendationsResourceWithStreamingRespons
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return RecommendationsResourceWithStreamingResponse(self)
 
@@ -95,7 +95,7 @@ def with_raw_response(self) -> AsyncRecommendationsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncRecommendationsResourceWithRawResponse(self)
 
@@ -104,7 +104,7 @@ def with_streaming_response(self) -> AsyncRecommendationsResourceWithStreamingRe
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncRecommendationsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv_shows/reviews.py b/src/tmdb_client/resources/tv_shows/reviews.py
index ce80843..0f590b7 100644
--- a/src/tmdb_client/resources/tv_shows/reviews.py
+++ b/src/tmdb_client/resources/tv_shows/reviews.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> ReviewsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ReviewsResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> ReviewsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ReviewsResourceWithStreamingResponse(self)
 
@@ -95,7 +95,7 @@ def with_raw_response(self) -> AsyncReviewsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncReviewsResourceWithRawResponse(self)
 
@@ -104,7 +104,7 @@ def with_streaming_response(self) -> AsyncReviewsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncReviewsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv_shows/screened_theatrically.py b/src/tmdb_client/resources/tv_shows/screened_theatrically.py
index 2587b6f..41503b7 100644
--- a/src/tmdb_client/resources/tv_shows/screened_theatrically.py
+++ b/src/tmdb_client/resources/tv_shows/screened_theatrically.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> ScreenedTheatricallyResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return ScreenedTheatricallyResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> ScreenedTheatricallyResourceWithStreamingRe
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return ScreenedTheatricallyResourceWithStreamingResponse(self)
 
@@ -78,7 +78,7 @@ def with_raw_response(self) -> AsyncScreenedTheatricallyResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncScreenedTheatricallyResourceWithRawResponse(self)
 
@@ -87,7 +87,7 @@ def with_streaming_response(self) -> AsyncScreenedTheatricallyResourceWithStream
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncScreenedTheatricallyResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv_shows/similar.py b/src/tmdb_client/resources/tv_shows/similar.py
index 4b6acdb..4350147 100644
--- a/src/tmdb_client/resources/tv_shows/similar.py
+++ b/src/tmdb_client/resources/tv_shows/similar.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> SimilarResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return SimilarResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> SimilarResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return SimilarResourceWithStreamingResponse(self)
 
@@ -97,7 +97,7 @@ def with_raw_response(self) -> AsyncSimilarResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncSimilarResourceWithRawResponse(self)
 
@@ -106,7 +106,7 @@ def with_streaming_response(self) -> AsyncSimilarResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncSimilarResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv_shows/top_rated.py b/src/tmdb_client/resources/tv_shows/top_rated.py
index 1b8cde1..dfa7b03 100644
--- a/src/tmdb_client/resources/tv_shows/top_rated.py
+++ b/src/tmdb_client/resources/tv_shows/top_rated.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> TopRatedResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return TopRatedResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> TopRatedResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return TopRatedResourceWithStreamingResponse(self)
 
@@ -94,7 +94,7 @@ def with_raw_response(self) -> AsyncTopRatedResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncTopRatedResourceWithRawResponse(self)
 
@@ -103,7 +103,7 @@ def with_streaming_response(self) -> AsyncTopRatedResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncTopRatedResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv_shows/translations.py b/src/tmdb_client/resources/tv_shows/translations.py
index 377a403..e0b20e9 100644
--- a/src/tmdb_client/resources/tv_shows/translations.py
+++ b/src/tmdb_client/resources/tv_shows/translations.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> TranslationsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return TranslationsResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> TranslationsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return TranslationsResourceWithStreamingResponse(self)
 
@@ -78,7 +78,7 @@ def with_raw_response(self) -> AsyncTranslationsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncTranslationsResourceWithRawResponse(self)
 
@@ -87,7 +87,7 @@ def with_streaming_response(self) -> AsyncTranslationsResourceWithStreamingRespo
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncTranslationsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv_shows/tv_shows.py b/src/tmdb_client/resources/tv_shows/tv_shows.py
index 897a564..6f909e9 100644
--- a/src/tmdb_client/resources/tv_shows/tv_shows.py
+++ b/src/tmdb_client/resources/tv_shows/tv_shows.py
@@ -267,7 +267,7 @@ def with_raw_response(self) -> TvShowsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return TvShowsResourceWithRawResponse(self)
 
@@ -276,7 +276,7 @@ def with_streaming_response(self) -> TvShowsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return TvShowsResourceWithStreamingResponse(self)
 
@@ -372,7 +372,7 @@ def with_raw_response(self) -> AsyncTvShowsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncTvShowsResourceWithRawResponse(self)
 
@@ -381,7 +381,7 @@ def with_streaming_response(self) -> AsyncTvShowsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncTvShowsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv_shows/videos.py b/src/tmdb_client/resources/tv_shows/videos.py
index a6e86c0..00d3f49 100644
--- a/src/tmdb_client/resources/tv_shows/videos.py
+++ b/src/tmdb_client/resources/tv_shows/videos.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> VideosResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return VideosResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> VideosResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return VideosResourceWithStreamingResponse(self)
 
@@ -98,7 +98,7 @@ def with_raw_response(self) -> AsyncVideosResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncVideosResourceWithRawResponse(self)
 
@@ -107,7 +107,7 @@ def with_streaming_response(self) -> AsyncVideosResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncVideosResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/tv_shows/watch_providers.py b/src/tmdb_client/resources/tv_shows/watch_providers.py
index cf0a7f5..7e8f9e3 100644
--- a/src/tmdb_client/resources/tv_shows/watch_providers.py
+++ b/src/tmdb_client/resources/tv_shows/watch_providers.py
@@ -26,7 +26,7 @@ def with_raw_response(self) -> WatchProvidersResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return WatchProvidersResourceWithRawResponse(self)
 
@@ -35,7 +35,7 @@ def with_streaming_response(self) -> WatchProvidersResourceWithStreamingResponse
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return WatchProvidersResourceWithStreamingResponse(self)
 
@@ -78,7 +78,7 @@ def with_raw_response(self) -> AsyncWatchProvidersResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncWatchProvidersResourceWithRawResponse(self)
 
@@ -87,7 +87,7 @@ def with_streaming_response(self) -> AsyncWatchProvidersResourceWithStreamingRes
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncWatchProvidersResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/watch_providers/movies.py b/src/tmdb_client/resources/watch_providers/movies.py
index 887a0e6..777ffea 100644
--- a/src/tmdb_client/resources/watch_providers/movies.py
+++ b/src/tmdb_client/resources/watch_providers/movies.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> MoviesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return MoviesResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> MoviesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return MoviesResourceWithStreamingResponse(self)
 
@@ -94,7 +94,7 @@ def with_raw_response(self) -> AsyncMoviesResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncMoviesResourceWithRawResponse(self)
 
@@ -103,7 +103,7 @@ def with_streaming_response(self) -> AsyncMoviesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncMoviesResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/watch_providers/regions.py b/src/tmdb_client/resources/watch_providers/regions.py
index 6b7ceb8..f9e28c3 100644
--- a/src/tmdb_client/resources/watch_providers/regions.py
+++ b/src/tmdb_client/resources/watch_providers/regions.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> RegionsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return RegionsResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> RegionsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return RegionsResourceWithStreamingResponse(self)
 
@@ -87,7 +87,7 @@ def with_raw_response(self) -> AsyncRegionsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncRegionsResourceWithRawResponse(self)
 
@@ -96,7 +96,7 @@ def with_streaming_response(self) -> AsyncRegionsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncRegionsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/watch_providers/tv_shows.py b/src/tmdb_client/resources/watch_providers/tv_shows.py
index 2a206af..d4f91fd 100644
--- a/src/tmdb_client/resources/watch_providers/tv_shows.py
+++ b/src/tmdb_client/resources/watch_providers/tv_shows.py
@@ -31,7 +31,7 @@ def with_raw_response(self) -> TvShowsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return TvShowsResourceWithRawResponse(self)
 
@@ -40,7 +40,7 @@ def with_streaming_response(self) -> TvShowsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return TvShowsResourceWithStreamingResponse(self)
 
@@ -94,7 +94,7 @@ def with_raw_response(self) -> AsyncTvShowsResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncTvShowsResourceWithRawResponse(self)
 
@@ -103,7 +103,7 @@ def with_streaming_response(self) -> AsyncTvShowsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncTvShowsResourceWithStreamingResponse(self)
 
diff --git a/src/tmdb_client/resources/watch_providers/watch_providers.py b/src/tmdb_client/resources/watch_providers/watch_providers.py
index 51f41e4..6fc6207 100644
--- a/src/tmdb_client/resources/watch_providers/watch_providers.py
+++ b/src/tmdb_client/resources/watch_providers/watch_providers.py
@@ -51,7 +51,7 @@ def with_raw_response(self) -> WatchProvidersResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return WatchProvidersResourceWithRawResponse(self)
 
@@ -60,7 +60,7 @@ def with_streaming_response(self) -> WatchProvidersResourceWithStreamingResponse
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return WatchProvidersResourceWithStreamingResponse(self)
 
@@ -84,7 +84,7 @@ def with_raw_response(self) -> AsyncWatchProvidersResourceWithRawResponse:
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#accessing-raw-response-data-eg-headers
         """
         return AsyncWatchProvidersResourceWithRawResponse(self)
 
@@ -93,7 +93,7 @@ def with_streaming_response(self) -> AsyncWatchProvidersResourceWithStreamingRes
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/stainless-sdks/tmdb-client-python#with_streaming_response
+        For more information, see https://www.github.com/jed-richards/tmdb-client-python#with_streaming_response
         """
         return AsyncWatchProvidersResourceWithStreamingResponse(self)
 
diff --git a/tests/test_client.py b/tests/test_client.py
index c91b0ae..67de356 100644
--- a/tests/test_client.py
+++ b/tests/test_client.py
@@ -364,11 +364,11 @@ def test_default_query_option(self) -> None:
             FinalRequestOptions(
                 method="get",
                 url="/foo",
-                params={"foo": "baz", "query_param": "overriden"},
+                params={"foo": "baz", "query_param": "overridden"},
             )
         )
         url = httpx.URL(request.url)
-        assert dict(url.params) == {"foo": "baz", "query_param": "overriden"}
+        assert dict(url.params) == {"foo": "baz", "query_param": "overridden"}
 
     def test_request_extra_json(self) -> None:
         request = self.client._build_request(
@@ -1148,11 +1148,11 @@ def test_default_query_option(self) -> None:
             FinalRequestOptions(
                 method="get",
                 url="/foo",
-                params={"foo": "baz", "query_param": "overriden"},
+                params={"foo": "baz", "query_param": "overridden"},
             )
         )
         url = httpx.URL(request.url)
-        assert dict(url.params) == {"foo": "baz", "query_param": "overriden"}
+        assert dict(url.params) == {"foo": "baz", "query_param": "overridden"}
 
     def test_request_extra_json(self) -> None:
         request = self.client._build_request(
diff --git a/tests/test_models.py b/tests/test_models.py
index 7210cf9..ee3be6c 100644
--- a/tests/test_models.py
+++ b/tests/test_models.py
@@ -1,7 +1,7 @@
 import json
 from typing import Any, Dict, List, Union, Optional, cast
 from datetime import datetime, timezone
-from typing_extensions import Literal, Annotated
+from typing_extensions import Literal, Annotated, TypeAliasType
 
 import pytest
 import pydantic
@@ -828,3 +828,19 @@ class B(BaseModel):
     # if the discriminator details object stays the same between invocations then
     # we hit the cache
     assert UnionType.__discriminator__ is discriminator
+
+
+@pytest.mark.skipif(not PYDANTIC_V2, reason="TypeAliasType is not supported in Pydantic v1")
+def test_type_alias_type() -> None:
+    Alias = TypeAliasType("Alias", str)
+
+    class Model(BaseModel):
+        alias: Alias
+        union: Union[int, Alias]
+
+    m = construct_type(value={"alias": "foo", "union": "bar"}, type_=Model)
+    assert isinstance(m, Model)
+    assert isinstance(m.alias, str)
+    assert m.alias == "foo"
+    assert isinstance(m.union, str)
+    assert m.union == "bar"
diff --git a/tests/utils.py b/tests/utils.py
index ca9953e..a9c43da 100644
--- a/tests/utils.py
+++ b/tests/utils.py
@@ -16,6 +16,7 @@
     is_union_type,
     extract_type_arg,
     is_annotated_type,
+    is_type_alias_type,
 )
 from tmdb_client._compat import PYDANTIC_V2, field_outer_type, get_model_fields
 from tmdb_client._models import BaseModel
@@ -51,6 +52,9 @@ def assert_matches_type(
     path: list[str],
     allow_none: bool = False,
 ) -> None:
+    if is_type_alias_type(type_):
+        type_ = type_.__value__
+
     # unwrap `Annotated[T, ...]` -> `T`
     if is_annotated_type(type_):
         type_ = extract_type_arg(type_, 0)