tmdb-lumosovich 0.7.0 → 0.8.0

package/README.md

@@ -6,7 +6,7 @@
 
 A small, typed Node.js wrapper for the TMDB API, including IMDb ID lookup through TMDB.
 
-**Lumosovich** is being built incrementally toward full TMDB v3 API coverage. It currently supports external-ID lookup, search, discovery, trending, movie and TV series catalogs and metadata, reviews, keywords, networks, collections, companies, configuration, movie, TV, and person details, and TV seasons, episodes, and episode groups.
+**Lumosovich** is being built incrementally toward full TMDB v3 API coverage. It currently supports external-ID lookup, search, discovery, trending, movie and TV series catalogs and metadata, reviews, keywords, networks, collections, companies, configuration, people and credit resources, and TV seasons, episodes, and episode groups.
 
 The name comes from **Lumos** — a spell for bringing light — with a little Russian-style `-ovich` treatment.
 
@@ -14,11 +14,11 @@ Light up the movie database.
 
 ## Current status
 
-Install [tmdb-lumosovich on npm](https://www.npmjs.com/package/tmdb-lumosovich), with source and issues on [GitHub](https://github.com/namipsg/lumosovich). Version `0.7.0` covers **109 of 152 TMDB v3 operations**, including all 48 TV operations, measured against the official specification pinned on September 27, 2026. This is an early `0.x` library; full API coverage is still in progress. See the [coverage baseline](https://github.com/namipsg/lumosovich/blob/main/spec/README.md) for how coverage is checked.
+Install [tmdb-lumosovich on npm](https://www.npmjs.com/package/tmdb-lumosovich), with source and issues on [GitHub](https://github.com/namipsg/lumosovich). Version `0.8.0` covers **121 of 152 TMDB v3 operations**, including all TV, person, and credit operations, measured against the official specification pinned on September 27, 2026. This is an early `0.x` library; full API coverage is still in progress. See the [coverage baseline](https://github.com/namipsg/lumosovich/blob/main/spec/README.md) for how coverage is checked.
 
-Version `0.7.0` moves the npm package from `lumosovich` to `tmdb-lumosovich`; the public `Lumosovich` class and TMDB API coverage are unchanged. Previously published `lumosovich` versions remain installable, but new projects should use `tmdb-lumosovich`. The read-only live smoke test exercises all 99 public read operations. Account-state and rating methods require a TMDB session and are verified by offline request contracts.
+The package moved from `lumosovich` to `tmdb-lumosovich` in version `0.7.1`; the public `Lumosovich` class kept its name. Previously published `lumosovich` versions remain installable, but new projects should use `tmdb-lumosovich`. The read-only live smoke test exercises all 111 public read operations. Account-state and rating methods require a TMDB session and are verified by offline request contracts.
 
-The release passes 180 offline tests and TypeScript declaration checks. See the [changelog](https://github.com/namipsg/lumosovich/blob/main/CHANGELOG.md) for earlier releases.
+The release passes 196 offline tests and TypeScript declaration checks. See the [changelog](https://github.com/namipsg/lumosovich/blob/main/CHANGELOG.md) for earlier releases.
 
 ## Installation
 
@@ -348,6 +348,30 @@ const group = groups.results[0]
 
 `changeList()` reports changed series IDs. Episode-group IDs are strings supplied by TMDB. The methods return TMDB's original response fields and preserve empty collections.
 
+## People and credits
+
+Use numeric TMDB person IDs for people resources. Credit details use the string `credit_id` returned in a person's cast or crew record.
+
+```js
+const personId = 31;
+const popularPeople = await tmdb.people.popular({ page: 1 });
+const movieCredits = await tmdb.people.movieCredits(personId);
+const tvCredits = await tmdb.people.tvCredits(personId);
+const combinedCredits = await tmdb.people.combinedCredits(personId);
+const creditId = movieCredits.cast[0]?.credit_id;
+const credit = creditId ? await tmdb.credits.get(creditId) : undefined;
+
+const externalIds = await tmdb.people.externalIds(personId);
+const portraits = await tmdb.people.images(personId);
+const tagged = await tmdb.people.taggedImages(personId, { page: 1 });
+const translations = await tmdb.people.translations(personId);
+const latestPerson = await tmdb.people.latest();
+const changedPeople = await tmdb.people.changeList({ page: 1 });
+const changes = await tmdb.people.changes(personId);
+```
+
+The three credit collections return `cast` and `crew` arrays with TMDB's original fields; `combinedCredits()` includes both movie and TV roles. `taggedImages()` has paginated image records, including episode stills, while `images()` has portrait profiles. TMDB can report `page: 0` for tagged images even when page 1 is requested. `changeList()` and `changes()` accept optional `startDate`, `endDate`, and `page`; dates use `YYYY-MM-DD`. `popular()` and `taggedImages()` accept a positive page. Credit details, popular people, and the three credit collections support a `language` override. `latest()` can be incomplete while a new person record is being edited on TMDB.
+
 ## Image URLs
 
 TMDB detail responses contain image paths. Build a safe public image URL with:
@@ -435,12 +459,12 @@ TMDB_API_KEY=... npm run test:live
 ```
 
 The credential is read from the environment, never from a tracked file. This checks
-all 99 public read operations. Account-state and rating methods require a TMDB
+all 111 public read operations. Account-state and rating methods require a TMDB
 session and are covered by offline contracts; the live test makes read-only requests.
 
 ## Roadmap
 
-People, lists, authentication, and the remaining TMDB resources will expand coverage in future releases. The [coverage ledger](https://github.com/namipsg/lumosovich/blob/main/spec/coverage.json) tracks implemented and remaining operations.
+Lists, authentication, and the remaining TMDB resources will expand coverage in future releases. The [coverage ledger](https://github.com/namipsg/lumosovich/blob/main/spec/coverage.json) tracks implemented and remaining operations.
 
 The goal is to cover the TMDB API while keeping the library:
 

package/dist/detail-types.d.ts

@@ -1,4 +1,5 @@
 import type { TmdbId } from './types.js';
+import type { PersonResourceMethods } from './person-types.js';
 import type { MovieMetadataMethods } from './metadata-types.js';
 import type { MovieCatalogMethods } from './catalog-types.js';
 import type { TvCatalogMethods, TvMetadataMethods } from './tv-types.js';
@@ -87,6 +88,7 @@ export interface TvContentRatingsResponse {
 }
 export interface PersonCredit {
     id: TmdbId;
+    credit_id?: string;
     media_type?: 'movie' | 'tv';
     title?: string;
     name?: string;
@@ -251,6 +253,6 @@ export interface TvMethods extends TvMetadataMethods, TvCatalogMethods, TvSeries
         get(seriesId: TmdbId, seasonNumber: number, episodeNumber: number, options?: EpisodeDetailOptions): Promise<TvEpisodeDetails>;
     };
 }
-export interface PersonMethods {
+export interface PersonMethods extends PersonResourceMethods {
     get(id: TmdbId, options?: PersonDetailOptions): Promise<PersonDetails>;
 }

package/dist/details.js

@@ -5,6 +5,7 @@ import { createTvMetadataMethods } from './tv-metadata.js';
 import { createTvSeriesResourceMethods, createTvEpisodeGroupMethods } from './tv-series-resources.js';
 import { createTvSeasonResourceMethods } from './tv-season-resources.js';
 import { createTvEpisodeResourceMethods } from './tv-episode-resources.js';
+import { createPersonResourceMethods } from './person-resources.js';
 import { positiveId, slotNumber } from './ids.js';
 import { validateDetailResponse, validateEpisodeResponse, validateSeasonResponse, } from './validation.js';
 const MOVIE_APPEND = [
@@ -104,6 +105,7 @@ export function createTvMethods(http) {
 }
 export function createPersonMethods(http) {
     return {
+        ...createPersonResourceMethods(http),
         async get(id, options = {}) {
             const validId = positiveId(id);
             const payload = await http.get(`person/${validId}`, detailParameters(options, PERSON_APPEND));

package/dist/index.cjs

@@ -915,6 +915,132 @@ function createTvEpisodeResourceMethods(http) {
   };
 }
 
+// src/person-validation.ts
+var positiveId2 = (value) => Number.isSafeInteger(value) && Number(value) > 0;
+var count2 = (value) => Number.isSafeInteger(value) && Number(value) >= 0;
+function validatePersonCredits(value, id) {
+  return validateIdShape(value, id, {
+    cast: metadataChecks.identities,
+    crew: metadataChecks.identities
+  });
+}
+function validatePopularPeople(value) {
+  const page3 = validateSearchPage(value);
+  if (!page3.results.every((person) => isRecord(person) && typeof person.name === "string")) {
+    invalidResponse();
+  }
+  return page3;
+}
+function validateTaggedImages(value, id) {
+  if (!isRecord(value) || value.id !== id || !count2(value.page) || !count2(value.total_pages) || !count2(value.total_results) || !Array.isArray(value.results) || !value.results.every((image) => isRecord(image) && typeof image.id === "string" && !!image.id && typeof image.file_path === "string" && typeof image.media_type === "string" && !!image.media_type && typeof image.image_type === "string" && isRecord(image.media) && positiveId2(image.media.id))) {
+    invalidResponse();
+  }
+  return value;
+}
+function validateCreditDetails(value, id) {
+  if (!isRecord(value) || value.id !== id || typeof value.credit_type !== "string" || !["movie", "tv"].includes(String(value.media_type)) || !isRecord(value.person) || !positiveId2(value.person.id) || typeof value.person.name !== "string" || !isRecord(value.media) || !positiveId2(value.media.id)) {
+    invalidResponse();
+  }
+  return value;
+}
+
+// src/person-resources.ts
+function createPersonResourceMethods(http) {
+  return {
+    async changeList(options = {}) {
+      return validateSearchPage(await http.get(
+        "person/changes",
+        changeParameters(options),
+        { includeLanguage: false }
+      ));
+    },
+    async changes(id, options = {}) {
+      const validId = positiveId(id);
+      return validateMovieChanges(await http.get(
+        `person/${validId}/changes`,
+        changeParameters(options),
+        { includeLanguage: false }
+      ));
+    },
+    async combinedCredits(id, options = {}) {
+      const validId = positiveId(id);
+      return validatePersonCredits(await http.get(`person/${validId}/combined_credits`, {
+        language: options.language
+      }), validId);
+    },
+    async externalIds(id) {
+      const validId = positiveId(id);
+      return validateIdShape(await http.get(
+        `person/${validId}/external_ids`,
+        {},
+        { includeLanguage: false }
+      ), validId, { imdb_id: metadataChecks.externalId, wikidata_id: metadataChecks.externalId });
+    },
+    async images(id) {
+      const validId = positiveId(id);
+      return validateIdShape(await http.get(
+        `person/${validId}/images`,
+        {},
+        { includeLanguage: false }
+      ), validId, { profiles: metadataChecks.images });
+    },
+    async latest() {
+      return validateLatestDetail(await http.get("person/latest", {}, { includeLanguage: false }), "name");
+    },
+    async movieCredits(id, options = {}) {
+      const validId = positiveId(id);
+      return validatePersonCredits(await http.get(`person/${validId}/movie_credits`, {
+        language: options.language
+      }), validId);
+    },
+    async popular(options = {}) {
+      if (options.page !== void 0 && (!Number.isSafeInteger(options.page) || options.page < 1)) {
+        throw new TypeError("page must be a positive integer");
+      }
+      return validatePopularPeople(await http.get("person/popular", {
+        language: options.language,
+        page: options.page
+      }));
+    },
+    async taggedImages(id, options = {}) {
+      const validId = positiveId(id);
+      if (options.page !== void 0 && (!Number.isSafeInteger(options.page) || options.page < 1)) {
+        throw new TypeError("page must be a positive integer");
+      }
+      return validateTaggedImages(await http.get(
+        `person/${validId}/tagged_images`,
+        { page: options.page },
+        { includeLanguage: false }
+      ), validId);
+    },
+    async translations(id) {
+      const validId = positiveId(id);
+      return validateIdShape(await http.get(
+        `person/${validId}/translations`,
+        {},
+        { includeLanguage: false }
+      ), validId, { translations: metadataChecks.translations });
+    },
+    async tvCredits(id, options = {}) {
+      const validId = positiveId(id);
+      return validatePersonCredits(await http.get(`person/${validId}/tv_credits`, {
+        language: options.language
+      }), validId);
+    }
+  };
+}
+function createCreditMethods(http) {
+  return {
+    async get(creditId, options = {}) {
+      const id = pathId(creditId, "credit ID");
+      return validateCreditDetails(await http.get(
+        `credit/${encodeURIComponent(id)}`,
+        { language: options.language }
+      ), id);
+    }
+  };
+}
+
 // src/details.ts
 var MOVIE_APPEND = [
   "credits",
@@ -1024,6 +1150,7 @@ function createTvMethods(http) {
 }
 function createPersonMethods(http) {
   return {
+    ...createPersonResourceMethods(http),
     async get(id, options = {}) {
       const validId = positiveId(id);
       const payload = await http.get(
@@ -1582,6 +1709,7 @@ var Lumosovich = class {
   networks;
   tv;
   people;
+  credits;
   images;
   configuration;
   certifications;
@@ -1623,6 +1751,7 @@ var Lumosovich = class {
     this.networks = createNetworkMethods(http);
     this.tv = createTvMethods(http);
     this.people = createPersonMethods(http);
+    this.credits = createCreditMethods(http);
     this.images = createImageMethods();
     this.configuration = createConfigurationMethods(http);
     this.certifications = createCertificationMethods(http);

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import type { CreditMethods } from './person-types.js';
 import type { CertificationMethods, ConfigurationMethods, GenreMethods } from './reference-types.js';
 import type { ExternalIdSource, FindOptions, FindResponse, LumosovichOptions, SearchMethods } from './types.js';
 import type { MovieMethods, PersonMethods, TvMethods } from './detail-types.js';
@@ -6,6 +7,7 @@ import type { CollectionMethods, CompanyMethods } from './metadata-types.js';
 import type { DiscoverMethods, KeywordMethods, NetworkMethods, ReviewMethods, TrendingMethods } from './catalog-types.js';
 export { TmdbError } from './errors.js';
 export type { TmdbErrorCode } from './errors.js';
+export type { CreditDetails, CreditMethods, PersonChangeListOptions, PersonChangeListPage, PersonChangesOptions, PersonChangesResponse, PersonCreditsResponse, PersonExternalIdsResponse, PersonImagesResponse, PersonPopularHit, PersonPopularPage, PersonResourceMethods, PersonTaggedImage, PersonTaggedImagesPage, PersonTranslationsResponse, } from './person-types.js';
 export type { ImageMethods, ImageSize } from './images.js';
 export type { DiscoverMethods, DiscoverCommonOptions, KeywordDetails, KeywordMethods, KeywordMoviesPage, MovieAccountStates, MovieCatalogMethods, MovieCatalogOptions, MovieCatalogPage, MovieChangeListOptions, MovieChangeListPage, MovieDiscoverOptions, MovieListHit, MovieListPage, NetworkAlternativeNamesResponse, NetworkDetails, NetworkImagesResponse, NetworkMethods, RatingResponse, RatingSession, ReviewDetails, ReviewMethods, ReviewPage, ReviewSummary, TrendingMethods, TrendingWindow, TvDiscoverOptions, } from './catalog-types.js';
 export type { Certification, CertificationMethods, CertificationsResponse, ConfigurationMethods, ConfigurationResponse, Country, CountryTimezones, DepartmentJobs, GenreMethods, GenresResponse, ImageConfiguration, Language, LanguageOptions, } from './reference-types.js';
@@ -30,6 +32,7 @@ export declare class Lumosovich {
     readonly networks: NetworkMethods;
     readonly tv: TvMethods;
     readonly people: PersonMethods;
+    readonly credits: CreditMethods;
     readonly images: ImageMethods;
     readonly configuration: ConfigurationMethods;
     readonly certifications: CertificationMethods;

package/dist/index.js

@@ -5,6 +5,7 @@ import { createCollectionMethods, createCompanyMethods } from './metadata.js';
 import { createDiscoverMethods } from './discover.js';
 import { createKeywordMethods, createNetworkMethods, createReviewMethods, createTrendingMethods, } from './explore.js';
 import { createSearchMethods } from './search.js';
+import { createCreditMethods } from './person-resources.js';
 import { createCertificationMethods, createConfigurationMethods, createGenreMethods } from './reference.js';
 import { validateFindResponse } from './validation.js';
 export { TmdbError } from './errors.js';
@@ -22,6 +23,7 @@ export class Lumosovich {
     networks;
     tv;
     people;
+    credits;
     images;
     configuration;
     certifications;
@@ -55,6 +57,7 @@ export class Lumosovich {
         this.networks = createNetworkMethods(http);
         this.tv = createTvMethods(http);
         this.people = createPersonMethods(http);
+        this.credits = createCreditMethods(http);
         this.images = createImageMethods();
         this.configuration = createConfigurationMethods(http);
         this.certifications = createCertificationMethods(http);

package/dist/person-resources.d.ts

@@ -0,0 +1,4 @@
+import { TmdbHttpClient } from './http.js';
+import type { PersonResourceMethods, CreditMethods } from './person-types.js';
+export declare function createPersonResourceMethods(http: TmdbHttpClient): PersonResourceMethods;
+export declare function createCreditMethods(http: TmdbHttpClient): CreditMethods;

package/dist/person-resources.js

@@ -0,0 +1,72 @@
+import { pathId, positiveId } from './ids.js';
+import { changeParameters } from './metadata.js';
+import { metadataChecks, validateIdShape, validateLatestDetail, validateMovieChanges } from './metadata-validation.js';
+import { validateSearchPage } from './validation.js';
+import { validateCreditDetails, validatePersonCredits, validatePopularPeople, validateTaggedImages } from './person-validation.js';
+export function createPersonResourceMethods(http) {
+    return {
+        async changeList(options = {}) {
+            return validateSearchPage(await http.get('person/changes', changeParameters(options), { includeLanguage: false }));
+        },
+        async changes(id, options = {}) {
+            const validId = positiveId(id);
+            return validateMovieChanges(await http.get(`person/${validId}/changes`, changeParameters(options), { includeLanguage: false }));
+        },
+        async combinedCredits(id, options = {}) {
+            const validId = positiveId(id);
+            return validatePersonCredits(await http.get(`person/${validId}/combined_credits`, {
+                language: options.language,
+            }), validId);
+        },
+        async externalIds(id) {
+            const validId = positiveId(id);
+            return validateIdShape(await http.get(`person/${validId}/external_ids`, {}, { includeLanguage: false }), validId, { imdb_id: metadataChecks.externalId, wikidata_id: metadataChecks.externalId });
+        },
+        async images(id) {
+            const validId = positiveId(id);
+            return validateIdShape(await http.get(`person/${validId}/images`, {}, { includeLanguage: false }), validId, { profiles: metadataChecks.images });
+        },
+        async latest() {
+            return validateLatestDetail(await http.get('person/latest', {}, { includeLanguage: false }), 'name');
+        },
+        async movieCredits(id, options = {}) {
+            const validId = positiveId(id);
+            return validatePersonCredits(await http.get(`person/${validId}/movie_credits`, {
+                language: options.language,
+            }), validId);
+        },
+        async popular(options = {}) {
+            if (options.page !== undefined && (!Number.isSafeInteger(options.page) || options.page < 1)) {
+                throw new TypeError('page must be a positive integer');
+            }
+            return validatePopularPeople(await http.get('person/popular', {
+                language: options.language, page: options.page,
+            }));
+        },
+        async taggedImages(id, options = {}) {
+            const validId = positiveId(id);
+            if (options.page !== undefined && (!Number.isSafeInteger(options.page) || options.page < 1)) {
+                throw new TypeError('page must be a positive integer');
+            }
+            return validateTaggedImages(await http.get(`person/${validId}/tagged_images`, { page: options.page }, { includeLanguage: false }), validId);
+        },
+        async translations(id) {
+            const validId = positiveId(id);
+            return validateIdShape(await http.get(`person/${validId}/translations`, {}, { includeLanguage: false }), validId, { translations: metadataChecks.translations });
+        },
+        async tvCredits(id, options = {}) {
+            const validId = positiveId(id);
+            return validatePersonCredits(await http.get(`person/${validId}/tv_credits`, {
+                language: options.language,
+            }), validId);
+        },
+    };
+}
+export function createCreditMethods(http) {
+    return {
+        async get(creditId, options = {}) {
+            const id = pathId(creditId, 'credit ID');
+            return validateCreditDetails(await http.get(`credit/${encodeURIComponent(id)}`, { language: options.language }), id);
+        },
+    };
+}

package/dist/person-types.d.ts

@@ -0,0 +1,86 @@
+import type { ImageAsset, PersonCredit, PersonDetails } from './detail-types.js';
+import type { MovieChangeListOptions } from './catalog-types.js';
+import type { MovieChangesOptions, MovieChangesResponse, TranslationsResponse } from './metadata-types.js';
+import type { LanguageOptions } from './reference-types.js';
+import type { PageOptions, SearchPage, TmdbId } from './types.js';
+export type PersonChangeListOptions = MovieChangeListOptions;
+export type PersonChangesOptions = MovieChangesOptions;
+export type PersonChangesResponse = MovieChangesResponse;
+export type PersonTranslationsResponse = TranslationsResponse;
+export type PersonChangeListPage = SearchPage<{
+    id: TmdbId;
+    adult?: boolean;
+    [key: string]: unknown;
+}>;
+export interface PersonPopularHit {
+    id: TmdbId;
+    name: string;
+    known_for?: Array<Record<string, unknown>>;
+    profile_path?: string | null;
+    [key: string]: unknown;
+}
+export type PersonPopularPage = SearchPage<PersonPopularHit>;
+export interface PersonCreditsResponse {
+    id: TmdbId;
+    cast: PersonCredit[];
+    crew: PersonCredit[];
+    [key: string]: unknown;
+}
+export interface PersonExternalIdsResponse {
+    id: TmdbId;
+    imdb_id?: string | null;
+    wikidata_id?: string | null;
+    [key: string]: unknown;
+}
+export interface PersonImagesResponse {
+    id: TmdbId;
+    profiles: ImageAsset[];
+    [key: string]: unknown;
+}
+export interface PersonTaggedImage extends ImageAsset {
+    id: string;
+    image_type: string;
+    media_type: string;
+    media: Record<string, unknown>;
+}
+export interface PersonTaggedImagesPage {
+    id: TmdbId;
+    page: number;
+    results: PersonTaggedImage[];
+    total_pages: number;
+    total_results: number;
+    [key: string]: unknown;
+}
+export interface CreditDetails {
+    id: string;
+    credit_type: string;
+    media_type: 'movie' | 'tv';
+    person: {
+        id: TmdbId;
+        name: string;
+        [key: string]: unknown;
+    };
+    media: {
+        id: TmdbId;
+        [key: string]: unknown;
+    };
+    department?: string;
+    job?: string;
+    [key: string]: unknown;
+}
+export interface CreditMethods {
+    get(creditId: string, options?: LanguageOptions): Promise<CreditDetails>;
+}
+export interface PersonResourceMethods {
+    changeList(options?: PersonChangeListOptions): Promise<PersonChangeListPage>;
+    changes(id: TmdbId, options?: PersonChangesOptions): Promise<PersonChangesResponse>;
+    combinedCredits(id: TmdbId, options?: LanguageOptions): Promise<PersonCreditsResponse>;
+    externalIds(id: TmdbId): Promise<PersonExternalIdsResponse>;
+    images(id: TmdbId): Promise<PersonImagesResponse>;
+    latest(): Promise<PersonDetails>;
+    movieCredits(id: TmdbId, options?: LanguageOptions): Promise<PersonCreditsResponse>;
+    popular(options?: PageOptions & LanguageOptions): Promise<PersonPopularPage>;
+    taggedImages(id: TmdbId, options?: PageOptions): Promise<PersonTaggedImagesPage>;
+    translations(id: TmdbId): Promise<PersonTranslationsResponse>;
+    tvCredits(id: TmdbId, options?: LanguageOptions): Promise<PersonCreditsResponse>;
+}

package/dist/person-types.js

@@ -0,0 +1 @@
+export {};

package/dist/person-validation.d.ts

@@ -0,0 +1,5 @@
+import type { CreditDetails, PersonTaggedImagesPage } from './person-types.js';
+export declare function validatePersonCredits<T>(value: unknown, id: number): T;
+export declare function validatePopularPeople<T>(value: unknown): T;
+export declare function validateTaggedImages(value: unknown, id: number): PersonTaggedImagesPage;
+export declare function validateCreditDetails(value: unknown, id: string): CreditDetails;

package/dist/person-validation.js

@@ -0,0 +1,40 @@
+import { invalidResponse, isRecord, validateSearchPage } from './validation.js';
+import { metadataChecks, validateIdShape } from './metadata-validation.js';
+const positiveId = (value) => Number.isSafeInteger(value) && Number(value) > 0;
+const count = (value) => Number.isSafeInteger(value) && Number(value) >= 0;
+export function validatePersonCredits(value, id) {
+    return validateIdShape(value, id, {
+        cast: metadataChecks.identities,
+        crew: metadataChecks.identities,
+    });
+}
+export function validatePopularPeople(value) {
+    const page = validateSearchPage(value);
+    if (!page.results.every((person) => isRecord(person) && typeof person.name === 'string')) {
+        invalidResponse();
+    }
+    return page;
+}
+export function validateTaggedImages(value, id) {
+    if (!isRecord(value) || value.id !== id || !count(value.page) ||
+        !count(value.total_pages) || !count(value.total_results) ||
+        !Array.isArray(value.results) || !value.results.every((image) => isRecord(image) && typeof image.id === 'string' && !!image.id &&
+        typeof image.file_path === 'string' &&
+        typeof image.media_type === 'string' && !!image.media_type &&
+        typeof image.image_type === 'string' && isRecord(image.media) &&
+        positiveId(image.media.id))) {
+        invalidResponse();
+    }
+    return value;
+}
+export function validateCreditDetails(value, id) {
+    if (!isRecord(value) || value.id !== id ||
+        typeof value.credit_type !== 'string' ||
+        !['movie', 'tv'].includes(String(value.media_type)) ||
+        !isRecord(value.person) || !positiveId(value.person.id) ||
+        typeof value.person.name !== 'string' ||
+        !isRecord(value.media) || !positiveId(value.media.id)) {
+        invalidResponse();
+    }
+    return value;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tmdb-lumosovich",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Typed Node.js client for the TMDB API with IMDb ID lookup for movies, TV shows, and people",
   "keywords": [
     "tmdb",