audible-api-ts 0.2.0 → 0.3.0

package/dist/categories.d.ts

@@ -1,7 +1,13 @@
 import type { AudibleLocale } from './types.js';
 /** Human-readable genre and sub-genre names for catalog search */
-export type AudibleGenre = 'science-fiction' | 'fantasy' | 'science-fiction-fantasy' | 'thriller' | 'mystery' | 'horror' | 'romance' | 'historical-fiction' | 'literary-fiction' | 'biography' | 'history' | 'business' | 'self-help' | 'science' | 'children' | 'young-adult' | 'comedy' | 'erotica' | 'religion' | 'sports' | 'travel' | 'lgbtq' | 'science-fiction/adventure' | 'science-fiction/adaptations' | 'science-fiction/cyberpunk' | 'science-fiction/dystopian' | 'science-fiction/first-contact' | 'science-fiction/galactic-empire' | 'science-fiction/genetic-engineering' | 'science-fiction/military' | 'science-fiction/post-apocalyptic' | 'science-fiction/space-exploration' | 'science-fiction/space-opera' | 'fantasy/action-adventure' | 'fantasy/adaptations' | 'fantasy/dragons' | 'fantasy/epic' | 'fantasy/historical' | 'fantasy/urban-paranormal' | 'thriller/suspense' | 'thriller/psychological' | 'thriller/domestic' | 'thriller/historical' | 'mystery/amateur-sleuth' | 'mystery/detective' | 'mystery/historical' | 'mystery/noir' | 'mystery/private-investigator' | 'mystery/traditional' | 'romance/action-adventure' | 'romance/comedy' | 'romance/contemporary' | 'romance/fantasy' | 'romance/historical' | 'romance/paranormal' | 'romance/science-fiction' | 'romance/sports' | 'romance/suspense' | 'literary-fiction/action-adventure' | 'literary-fiction/classics' | 'literary-fiction/coming-of-age' | 'literary-fiction/contemporary' | 'literary-fiction/drama' | 'literary-fiction/family-life' | 'literary-fiction/historical' | 'literary-fiction/sagas' | 'literary-fiction/sea-adventures' | 'literary-fiction/world-literature' | 'biography/entertainment' | 'history/europe' | 'children/action-adventure' | 'young-adult/literary-fiction' | 'young-adult/romance' | 'young-adult/science-fiction-fantasy' | 'young-adult/thriller';
-/** Mapping from genre name to locale-specific Audible category ID */
+export type AudibleGenre = 'science-fiction' | 'fantasy' | 'science-fiction-fantasy' | 'mystery-thriller-suspense' | 'thriller' | 'mystery' | 'crime-fiction' | 'horror' | 'romance' | 'historical-fiction' | 'literary-fiction' | 'biography' | 'history' | 'business' | 'self-help' | 'science' | 'children' | 'young-adult' | 'comedy' | 'erotica' | 'religion' | 'sports' | 'travel' | 'lgbtq' | 'science-fiction/adventure' | 'science-fiction/adaptations' | 'science-fiction/cyberpunk' | 'science-fiction/dystopian' | 'science-fiction/first-contact' | 'science-fiction/galactic-empire' | 'science-fiction/genetic-engineering' | 'science-fiction/military' | 'science-fiction/post-apocalyptic' | 'science-fiction/space-exploration' | 'science-fiction/space-opera' | 'fantasy/action-adventure' | 'fantasy/adaptations' | 'fantasy/dragons' | 'fantasy/epic' | 'fantasy/historical' | 'fantasy/sword-sorcery' | 'fantasy/urban-paranormal' | 'thriller/suspense' | 'thriller/psychological' | 'thriller/domestic' | 'thriller/historical' | 'mystery/amateur-sleuth' | 'mystery/cozy' | 'mystery/detective' | 'mystery/hard-boiled' | 'mystery/historical' | 'mystery/noir' | 'mystery/police-procedural' | 'mystery/private-investigator' | 'mystery/traditional' | 'romance/action-adventure' | 'romance/comedy' | 'romance/contemporary' | 'romance/fantasy' | 'romance/historical' | 'romance/paranormal' | 'romance/science-fiction' | 'romance/sports' | 'romance/suspense' | 'literary-fiction/action-adventure' | 'literary-fiction/classics' | 'literary-fiction/coming-of-age' | 'literary-fiction/contemporary' | 'literary-fiction/drama' | 'literary-fiction/family-life' | 'literary-fiction/fiction' | 'literary-fiction/historical' | 'literary-fiction/sagas' | 'literary-fiction/sea-adventures' | 'literary-fiction/world-literature' | 'biography/entertainment' | 'history/europe' | 'children/action-adventure' | 'children/mystery' | 'children/science-fiction-fantasy' | 'children/fantasy' | 'children/science-fiction' | 'young-adult/literary-fiction' | 'young-adult/romance' | 'young-adult/science-fiction-fantasy' | 'young-adult/fantasy' | 'young-adult/science-fiction' | 'young-adult/thriller';
+/**
+ * Mapping from genre name to locale-specific Audible category ID.
+ *
+ * Every id is checked against the live catalogue by `categories.int.test.ts`, which
+ * asserts the name Audible gives it. A category can sit under several parents, so
+ * the id is the same wherever the store shows it.
+ */
 export declare const GENRE_CATEGORIES: Record<AudibleGenre, Partial<Record<AudibleLocale, string>>>;
 /**
  * Resolve a genre name to a locale-specific Audible category ID.

package/dist/categories.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"categories.d.ts","sourceRoot":"","sources":["../src/categories.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE/C,kEAAkE;AAClE,MAAM,MAAM,YAAY,GAEpB,iBAAiB,GACjB,SAAS,GACT,yBAAyB,GACzB,UAAU,GACV,SAAS,GACT,QAAQ,GACR,SAAS,GACT,oBAAoB,GACpB,kBAAkB,GAClB,WAAW,GACX,SAAS,GACT,UAAU,GACV,WAAW,GACX,SAAS,GACT,UAAU,GACV,aAAa,GACb,QAAQ,GACR,SAAS,GACT,UAAU,GACV,QAAQ,GACR,QAAQ,GACR,OAAO,GAEP,2BAA2B,GAC3B,6BAA6B,GAC7B,2BAA2B,GAC3B,2BAA2B,GAC3B,+BAA+B,GAC/B,iCAAiC,GACjC,qCAAqC,GACrC,0BAA0B,GAC1B,kCAAkC,GAClC,mCAAmC,GACnC,6BAA6B,GAE7B,0BAA0B,GAC1B,qBAAqB,GACrB,iBAAiB,GACjB,cAAc,GACd,oBAAoB,GACpB,0BAA0B,GAE1B,mBAAmB,GACnB,wBAAwB,GACxB,mBAAmB,GACnB,qBAAqB,GAErB,wBAAwB,GACxB,mBAAmB,GACnB,oBAAoB,GACpB,cAAc,GACd,8BAA8B,GAC9B,qBAAqB,GAErB,0BAA0B,GAC1B,gBAAgB,GAChB,sBAAsB,GACtB,iBAAiB,GACjB,oBAAoB,GACpB,oBAAoB,GACpB,yBAAyB,GACzB,gBAAgB,GAChB,kBAAkB,GAElB,mCAAmC,GACnC,2BAA2B,GAC3B,gCAAgC,GAChC,+BAA+B,GAC/B,wBAAwB,GACxB,8BAA8B,GAC9B,6BAA6B,GAC7B,wBAAwB,GACxB,iCAAiC,GACjC,mCAAmC,GAEnC,yBAAyB,GAEzB,gBAAgB,GAEhB,2BAA2B,GAE3B,8BAA8B,GAC9B,qBAAqB,GACrB,qCAAqC,GACrC,sBAAsB,CAAA;AAE1B,qEAAqE;AACrE,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,YAAY,EAAE,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC,CAiGzF,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,YAAY,EAAE,QAAQ,aAAa,WAQxE,CAAA"}
+{"version":3,"file":"categories.d.ts","sourceRoot":"","sources":["../src/categories.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE/C,kEAAkE;AAClE,MAAM,MAAM,YAAY,GAEpB,iBAAiB,GACjB,SAAS,GACT,yBAAyB,GACzB,2BAA2B,GAC3B,UAAU,GACV,SAAS,GACT,eAAe,GACf,QAAQ,GACR,SAAS,GACT,oBAAoB,GACpB,kBAAkB,GAClB,WAAW,GACX,SAAS,GACT,UAAU,GACV,WAAW,GACX,SAAS,GACT,UAAU,GACV,aAAa,GACb,QAAQ,GACR,SAAS,GACT,UAAU,GACV,QAAQ,GACR,QAAQ,GACR,OAAO,GAEP,2BAA2B,GAC3B,6BAA6B,GAC7B,2BAA2B,GAC3B,2BAA2B,GAC3B,+BAA+B,GAC/B,iCAAiC,GACjC,qCAAqC,GACrC,0BAA0B,GAC1B,kCAAkC,GAClC,mCAAmC,GACnC,6BAA6B,GAE7B,0BAA0B,GAC1B,qBAAqB,GACrB,iBAAiB,GACjB,cAAc,GACd,oBAAoB,GACpB,uBAAuB,GACvB,0BAA0B,GAE1B,mBAAmB,GACnB,wBAAwB,GACxB,mBAAmB,GACnB,qBAAqB,GAErB,wBAAwB,GACxB,cAAc,GACd,mBAAmB,GACnB,qBAAqB,GACrB,oBAAoB,GACpB,cAAc,GACd,2BAA2B,GAC3B,8BAA8B,GAC9B,qBAAqB,GAErB,0BAA0B,GAC1B,gBAAgB,GAChB,sBAAsB,GACtB,iBAAiB,GACjB,oBAAoB,GACpB,oBAAoB,GACpB,yBAAyB,GACzB,gBAAgB,GAChB,kBAAkB,GAElB,mCAAmC,GACnC,2BAA2B,GAC3B,gCAAgC,GAChC,+BAA+B,GAC/B,wBAAwB,GACxB,8BAA8B,GAC9B,0BAA0B,GAC1B,6BAA6B,GAC7B,wBAAwB,GACxB,iCAAiC,GACjC,mCAAmC,GAEnC,yBAAyB,GAEzB,gBAAgB,GAEhB,2BAA2B,GAC3B,kBAAkB,GAClB,kCAAkC,GAClC,kBAAkB,GAClB,0BAA0B,GAE1B,8BAA8B,GAC9B,qBAAqB,GACrB,qCAAqC,GACrC,qBAAqB,GACrB,6BAA6B,GAC7B,sBAAsB,CAAA;AAE1B;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,YAAY,EAAE,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC,CA8GzF,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,YAAY,EAAE,QAAQ,aAAa,WAQxE,CAAA"}

package/dist/categories.int.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=categories.int.test.d.ts.map

package/dist/categories.int.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"categories.int.test.d.ts","sourceRoot":"","sources":["../src/categories.int.test.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -656,8 +656,8 @@ function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
       break;
     }
     if (seen) {
-      if (!_arraySome_default(other, function(othValue2, othIndex) {
-        if (!_cacheHas_default(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
+      if (!_arraySome_default(other, function(othValue, othIndex) {
+        if (!_cacheHas_default(seen, othIndex) && (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
           return seen.push(othIndex);
         }
       })) {
@@ -1389,8 +1389,8 @@ var _baseEach_default = baseEach;
 // node_modules/lodash-es/_baseMap.js
 function baseMap(collection, iteratee) {
   var index = -1, result = isArrayLike_default(collection) ? Array(collection.length) : [];
-  _baseEach_default(collection, function(value, key, collection2) {
-    result[++index] = iteratee(value, key, collection2);
+  _baseEach_default(collection, function(value, key, collection) {
+    result[++index] = iteratee(value, key, collection);
   });
   return result;
 }
@@ -1456,7 +1456,7 @@ function baseOrderBy(collection, iteratees, orders) {
   }
   var index = -1;
   iteratees = _arrayMap_default(iteratees, _baseUnary_default(_baseIteratee_default));
-  var result = _baseMap_default(collection, function(value, key, collection2) {
+  var result = _baseMap_default(collection, function(value, key, collection) {
     var criteria = _arrayMap_default(iteratees, function(iteratee) {
       return iteratee(value);
     });
@@ -1603,78 +1603,91 @@ var GENRE_CATEGORIES = {
   "science-fiction": { fr: "21229020031", com: "18580628011" },
   fantasy: { fr: "21229021031", com: "18580607011" },
   "science-fiction-fantasy": { fr: "21228885031", com: "18580606011" },
-  thriller: { fr: "21228906031", com: "18574449011" },
-  mystery: { fr: "21228905031", com: "18574427011" },
-  horror: { fr: "21229011031", com: "18573211011" },
+  "mystery-thriller-suspense": { fr: "21228876031", com: "18574597011" },
+  thriller: { fr: "21228906031", com: "18574621011" },
+  mystery: { fr: "21228905031", com: "18574606011" },
+  "crime-fiction": { fr: "21228907031", com: "18574598011" },
+  horror: { fr: "21229011031", com: "18574490011" },
   romance: { fr: "21228893031", com: "18580518011" },
-  "historical-fiction": { fr: "21229010031" },
-  "literary-fiction": { fr: "21228884031", com: "18574784011" },
+  "historical-fiction": { fr: "21229010031", com: "18574482011" },
+  "literary-fiction": { fr: "21228884031", com: "18574426011" },
   biography: { fr: "21228881031", com: "18571951011" },
-  history: { fr: "21228890031" },
-  business: { fr: "21228882031", com: "18571961011" },
-  "self-help": { fr: "21228892031", com: "18571967011" },
-  science: { fr: "21228897031", com: "18571997011" },
+  history: { fr: "21228890031", com: "18573518011" },
+  business: { fr: "21228882031", com: "18572029011" },
+  "self-help": { fr: "21228892031", com: "18574784011" },
+  science: { fr: "21228897031", com: "18580540011" },
   children: { fr: "21228877031", com: "18572091011" },
-  "young-adult": { fr: "21228895031" },
-  comedy: { fr: "34003928031", com: "18572049011" },
-  erotica: { fr: "21228894031", com: "18573267011" },
-  religion: { fr: "21228880031", com: "18574606011" },
-  sports: { fr: "21228879031", com: "18574713011" },
-  travel: { fr: "21228891031", com: "18574721011" },
-  lgbtq: { fr: "21228883031", com: "18573939011" },
+  "young-adult": { fr: "21228895031", com: "18580715011" },
+  comedy: { fr: "34003928031", com: "24427740011" },
+  erotica: { fr: "21228894031", com: "18573351011" },
+  religion: { fr: "21228880031", com: "18574839011" },
+  sports: { fr: "21228879031", com: "18580648011" },
+  travel: { fr: "21228891031", com: "18581095011" },
+  lgbtq: { fr: "21228883031", com: "18573743011" },
   "science-fiction/adventure": { fr: "21229681031", com: "18580629011" },
-  "science-fiction/adaptations": { fr: "21229683031" },
+  "science-fiction/adaptations": { fr: "21229683031", com: "18580642011" },
   "science-fiction/cyberpunk": { fr: "21229684031", com: "18580633011" },
-  "science-fiction/dystopian": { fr: "21229685031", com: "18580634011" },
-  "science-fiction/first-contact": { fr: "21229682031", com: "18580635011" },
-  "science-fiction/galactic-empire": { fr: "21229693031", com: "18580636011" },
-  "science-fiction/genetic-engineering": { fr: "21229686031", com: "18580637011" },
-  "science-fiction/military": { fr: "21229688031", com: "18580643011" },
-  "science-fiction/post-apocalyptic": { fr: "21229687031", com: "18580645011" },
-  "science-fiction/space-exploration": { fr: "21229689031", com: "18580647011" },
-  "science-fiction/space-opera": { fr: "21229694031", com: "18580648011" },
+  "science-fiction/dystopian": { fr: "21229685031", com: "18580635011" },
+  "science-fiction/first-contact": { fr: "21229682031", com: "18580636011" },
+  "science-fiction/galactic-empire": { fr: "21229693031" },
+  "science-fiction/genetic-engineering": { fr: "21229686031", com: "18580638011" },
+  "science-fiction/military": { fr: "21229688031", com: "18580641011" },
+  "science-fiction/post-apocalyptic": { fr: "21229687031", com: "18580643011" },
+  "science-fiction/space-exploration": { fr: "21229689031", com: "18580644011" },
+  "science-fiction/space-opera": { fr: "21229694031", com: "18580645011" },
   "fantasy/action-adventure": { fr: "21229712031", com: "18580608011" },
-  "fantasy/adaptations": { fr: "21229708031" },
-  "fantasy/dragons": { fr: "21229709031", com: "18580612011" },
-  "fantasy/epic": { fr: "21229701031", com: "18580614011" },
-  "fantasy/historical": { fr: "21229700031", com: "18580616011" },
-  "fantasy/urban-paranormal": { fr: "21229711031", com: "18580621011" },
-  "thriller/suspense": { fr: "21229158031", com: "18574450011" },
-  "thriller/psychological": { fr: "21229165031", com: "18574459011" },
-  "thriller/domestic": { fr: "21229163031", com: "18574455011" },
-  "thriller/historical": { fr: "21229168031", com: "18574456011" },
-  "mystery/amateur-sleuth": { fr: "21229145031", com: "18574430011" },
-  "mystery/detective": { fr: "21229148031" },
-  "mystery/historical": { fr: "21229155031", com: "18574435011" },
-  "mystery/noir": { fr: "21229177031", com: "18574434011" },
-  "mystery/private-investigator": { fr: "21229148031", com: "18574439011" },
-  "mystery/traditional": { fr: "21229152031", com: "18574443011" },
-  "romance/action-adventure": { fr: "21229096031" },
-  "romance/comedy": { fr: "21229087031" },
-  "romance/contemporary": { fr: "21230152031" },
-  "romance/fantasy": { fr: "21229095031" },
-  "romance/historical": { fr: "21229093031" },
-  "romance/paranormal": { fr: "21229088031" },
-  "romance/science-fiction": { fr: "21229085031" },
-  "romance/sports": { fr: "21229086031" },
-  "romance/suspense": { fr: "21229090031" },
-  "literary-fiction/action-adventure": { fr: "21230085031" },
-  "literary-fiction/classics": { fr: "21229007031" },
-  "literary-fiction/coming-of-age": { fr: "21230090031" },
-  "literary-fiction/contemporary": { fr: "21229657031" },
-  "literary-fiction/drama": { fr: "21229017031" },
-  "literary-fiction/family-life": { fr: "21229670031" },
-  "literary-fiction/historical": { fr: "21229010031" },
-  "literary-fiction/sagas": { fr: "21229654031" },
-  "literary-fiction/sea-adventures": { fr: "21229673031" },
-  "literary-fiction/world-literature": { fr: "21229018031" },
-  "biography/entertainment": { fr: "21228985031" },
-  "history/europe": { fr: "21229067031" },
-  "children/action-adventure": { fr: "21228913031" },
-  "young-adult/literary-fiction": { fr: "21229110031" },
-  "young-adult/romance": { fr: "21229117031" },
-  "young-adult/science-fiction-fantasy": { fr: "21229103031" },
-  "young-adult/thriller": { fr: "21229114031" }
+  "fantasy/adaptations": { fr: "21229708031", com: "18580621011" },
+  "fantasy/dragons": { fr: "21229709031", com: "18580613011" },
+  "fantasy/epic": { fr: "21229701031", com: "18580615011" },
+  "fantasy/historical": { fr: "21229700031", com: "18580618011" },
+  "fantasy/sword-sorcery": { fr: "21229713031", com: "18580627011" },
+  "fantasy/urban-paranormal": { fr: "21229711031", com: "18580622011" },
+  "thriller/suspense": { fr: "21229158031", com: "18574639011" },
+  "thriller/psychological": { fr: "21229165031", com: "18574631011" },
+  "thriller/domestic": { fr: "21229163031", com: "18574624011" },
+  "thriller/historical": { fr: "21229168031", com: "18574627011" },
+  "mystery/amateur-sleuth": { fr: "21229145031", com: "18574607011" },
+  "mystery/cozy": { fr: "21229150031", com: "18574609011" },
+  "mystery/detective": { fr: "21229148031", com: "18574618011" },
+  "mystery/hard-boiled": { fr: "21229153031", com: "18574614011" },
+  "mystery/historical": { fr: "21229155031", com: "18574615011" },
+  "mystery/noir": { fr: "21229177031", com: "18574602011" },
+  "mystery/police-procedural": { fr: "21229144031", com: "18574617011" },
+  "mystery/private-investigator": { fr: "21229148031", com: "18574618011" },
+  "mystery/traditional": { fr: "21229152031", com: "18574619011" },
+  "romance/action-adventure": { fr: "21229096031", com: "18580519011" },
+  "romance/comedy": { fr: "21229087031", com: "18580535011" },
+  "romance/contemporary": { fr: "21230152031", com: "18580522011" },
+  "romance/fantasy": { fr: "21229095031", com: "18580523011" },
+  "romance/historical": { fr: "21229093031", com: "18580524011" },
+  "romance/paranormal": { fr: "21229088031", com: "18580534011" },
+  "romance/science-fiction": { fr: "21229085031", com: "18580537011" },
+  "romance/sports": { fr: "21229086031", com: "18580538011" },
+  "romance/suspense": { fr: "21229090031", com: "18580536011" },
+  "literary-fiction/action-adventure": { fr: "21229016031", com: "18574427011" },
+  "literary-fiction/classics": { fr: "21229007031", com: "18574449011" },
+  "literary-fiction/coming-of-age": { fr: "21229655031", com: "18574461011" },
+  "literary-fiction/contemporary": { fr: "21229657031", com: "18574462011" },
+  "literary-fiction/drama": { fr: "21229017031", com: "18574450011" },
+  "literary-fiction/family-life": { fr: "21229670031", com: "18574465011" },
+  "literary-fiction/fiction": { fr: "21229019031", com: "18574456011" },
+  "literary-fiction/historical": { fr: "21229010031", com: "18574482011" },
+  "literary-fiction/sagas": { fr: "21229654031", com: "18574476011" },
+  "literary-fiction/sea-adventures": { fr: "21229673031", com: "18574434011" },
+  "literary-fiction/world-literature": { fr: "21229018031", com: "18574521011" },
+  "biography/entertainment": { fr: "21228985031", com: "18571984011" },
+  "history/europe": { fr: "21229067031", com: "18573582011" },
+  "children/action-adventure": { fr: "21228913031", com: "18572092011" },
+  "children/mystery": { fr: "21228927031", com: "18572548011" },
+  "children/science-fiction-fantasy": { fr: "21228926031", com: "18572586011" },
+  "children/fantasy": { fr: "21229338031", com: "18572587011" },
+  "children/science-fiction": { fr: "21229339031", com: "18572593011" },
+  "young-adult/literary-fiction": { fr: "21229110031", com: "18580894011" },
+  "young-adult/romance": { fr: "21229117031", com: "18581004011" },
+  "young-adult/science-fiction-fantasy": { fr: "21229103031", com: "18581048011" },
+  "young-adult/fantasy": { fr: "21230013031", com: "18581049011" },
+  "young-adult/science-fiction": { fr: "21230014031", com: "18581062011" },
+  "young-adult/thriller": { fr: "21229114031", com: "18580961011" }
 };
 var resolveGenreId = (genre, locale) => {
   const id = GENRE_CATEGORIES[genre]?.[locale];
@@ -1838,170 +1851,58 @@ var refresh = async (credentials) => {
   };
 };
 
-// node_modules/zod/v3/external.js
-var exports_external = {};
-__export(exports_external, {
-  void: () => voidType,
-  util: () => util,
-  unknown: () => unknownType,
-  union: () => unionType,
-  undefined: () => undefinedType,
-  tuple: () => tupleType,
-  transformer: () => effectsType,
-  symbol: () => symbolType,
-  string: () => stringType,
-  strictObject: () => strictObjectType,
-  setErrorMap: () => setErrorMap,
-  set: () => setType,
-  record: () => recordType,
-  quotelessJson: () => quotelessJson,
-  promise: () => promiseType,
-  preprocess: () => preprocessType,
-  pipeline: () => pipelineType,
-  ostring: () => ostring,
-  optional: () => optionalType,
-  onumber: () => onumber,
-  oboolean: () => oboolean,
-  objectUtil: () => objectUtil,
-  object: () => objectType,
-  number: () => numberType,
-  nullable: () => nullableType,
-  null: () => nullType,
-  never: () => neverType,
-  nativeEnum: () => nativeEnumType,
-  nan: () => nanType,
-  map: () => mapType,
-  makeIssue: () => makeIssue,
-  literal: () => literalType,
-  lazy: () => lazyType,
-  late: () => late,
-  isValid: () => isValid,
-  isDirty: () => isDirty,
-  isAsync: () => isAsync,
-  isAborted: () => isAborted,
-  intersection: () => intersectionType,
-  instanceof: () => instanceOfType,
-  getParsedType: () => getParsedType,
-  getErrorMap: () => getErrorMap,
-  function: () => functionType,
-  enum: () => enumType,
-  effect: () => effectsType,
-  discriminatedUnion: () => discriminatedUnionType,
-  defaultErrorMap: () => en_default,
-  datetimeRegex: () => datetimeRegex,
-  date: () => dateType,
-  custom: () => custom,
-  coerce: () => coerce,
-  boolean: () => booleanType,
-  bigint: () => bigIntType,
-  array: () => arrayType,
-  any: () => anyType,
-  addIssueToContext: () => addIssueToContext,
-  ZodVoid: () => ZodVoid,
-  ZodUnknown: () => ZodUnknown,
-  ZodUnion: () => ZodUnion,
-  ZodUndefined: () => ZodUndefined,
-  ZodType: () => ZodType,
-  ZodTuple: () => ZodTuple,
-  ZodTransformer: () => ZodEffects,
-  ZodSymbol: () => ZodSymbol,
-  ZodString: () => ZodString,
-  ZodSet: () => ZodSet,
-  ZodSchema: () => ZodType,
-  ZodRecord: () => ZodRecord,
-  ZodReadonly: () => ZodReadonly,
-  ZodPromise: () => ZodPromise,
-  ZodPipeline: () => ZodPipeline,
-  ZodParsedType: () => ZodParsedType,
-  ZodOptional: () => ZodOptional,
-  ZodObject: () => ZodObject,
-  ZodNumber: () => ZodNumber,
-  ZodNullable: () => ZodNullable,
-  ZodNull: () => ZodNull,
-  ZodNever: () => ZodNever,
-  ZodNativeEnum: () => ZodNativeEnum,
-  ZodNaN: () => ZodNaN,
-  ZodMap: () => ZodMap,
-  ZodLiteral: () => ZodLiteral,
-  ZodLazy: () => ZodLazy,
-  ZodIssueCode: () => ZodIssueCode,
-  ZodIntersection: () => ZodIntersection,
-  ZodFunction: () => ZodFunction,
-  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
-  ZodError: () => ZodError,
-  ZodEnum: () => ZodEnum,
-  ZodEffects: () => ZodEffects,
-  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
-  ZodDefault: () => ZodDefault,
-  ZodDate: () => ZodDate,
-  ZodCatch: () => ZodCatch,
-  ZodBranded: () => ZodBranded,
-  ZodBoolean: () => ZodBoolean,
-  ZodBigInt: () => ZodBigInt,
-  ZodArray: () => ZodArray,
-  ZodAny: () => ZodAny,
-  Schema: () => ZodType,
-  ParseStatus: () => ParseStatus,
-  OK: () => OK,
-  NEVER: () => NEVER,
-  INVALID: () => INVALID,
-  EMPTY_PATH: () => EMPTY_PATH,
-  DIRTY: () => DIRTY,
-  BRAND: () => BRAND
-});
-
 // node_modules/zod/v3/helpers/util.js
 var util;
-(function(util2) {
-  util2.assertEqual = (_) => {};
+(function(util) {
+  util.assertEqual = (_) => {};
   function assertIs(_arg) {}
-  util2.assertIs = assertIs;
+  util.assertIs = assertIs;
   function assertNever(_x) {
     throw new Error;
   }
-  util2.assertNever = assertNever;
-  util2.arrayToEnum = (items) => {
+  util.assertNever = assertNever;
+  util.arrayToEnum = (items) => {
     const obj = {};
     for (const item of items) {
       obj[item] = item;
     }
     return obj;
   };
-  util2.getValidEnumValues = (obj) => {
-    const validKeys = util2.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
+  util.getValidEnumValues = (obj) => {
+    const validKeys = util.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
     const filtered = {};
     for (const k of validKeys) {
       filtered[k] = obj[k];
     }
-    return util2.objectValues(filtered);
+    return util.objectValues(filtered);
   };
-  util2.objectValues = (obj) => {
-    return util2.objectKeys(obj).map(function(e) {
+  util.objectValues = (obj) => {
+    return util.objectKeys(obj).map(function(e) {
       return obj[e];
     });
   };
-  util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
-    const keys2 = [];
+  util.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
+    const keys = [];
     for (const key in object) {
       if (Object.prototype.hasOwnProperty.call(object, key)) {
-        keys2.push(key);
+        keys.push(key);
       }
     }
-    return keys2;
+    return keys;
   };
-  util2.find = (arr, checker) => {
+  util.find = (arr, checker) => {
     for (const item of arr) {
       if (checker(item))
         return item;
     }
     return;
   };
-  util2.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
+  util.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
   function joinValues(array, separator = " | ") {
     return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
   }
-  util2.joinValues = joinValues;
-  util2.jsonStringifyReplacer = (_, value) => {
+  util.joinValues = joinValues;
+  util.jsonStringifyReplacer = (_, value) => {
     if (typeof value === "bigint") {
       return value.toString();
     }
@@ -2009,8 +1910,8 @@ var util;
   };
 })(util || (util = {}));
 var objectUtil;
-(function(objectUtil2) {
-  objectUtil2.mergeShapes = (first, second) => {
+(function(objectUtil) {
+  objectUtil.mergeShapes = (first, second) => {
     return {
       ...first,
       ...second
@@ -2100,11 +2001,6 @@ var ZodIssueCode = util.arrayToEnum([
   "not_multiple_of",
   "not_finite"
 ]);
-var quotelessJson = (obj) => {
-  const json = JSON.stringify(obj, null, 2);
-  return json.replace(/"([^"]+)":/g, "$1:");
-};
-
 class ZodError extends Error {
   get errors() {
     return this.issues;
@@ -2305,12 +2201,10 @@ var en_default = errorMap;
 
 // node_modules/zod/v3/errors.js
 var overrideErrorMap = en_default;
-function setErrorMap(map) {
-  overrideErrorMap = map;
-}
 function getErrorMap() {
   return overrideErrorMap;
 }
+
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
   const { data, path, errorMaps, issueData } = params;
@@ -2337,7 +2231,6 @@ var makeIssue = (params) => {
     message: errorMessage
   };
 };
-var EMPTY_PATH = [];
 function addIssueToContext(ctx, issueData) {
   const overrideMap = getErrorMap();
   const issue = makeIssue({
@@ -2417,11 +2310,12 @@ var isAborted = (x) => x.status === "aborted";
 var isDirty = (x) => x.status === "dirty";
 var isValid = (x) => x.status === "valid";
 var isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
+
 // node_modules/zod/v3/helpers/errorUtil.js
 var errorUtil;
-(function(errorUtil2) {
-  errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {};
-  errorUtil2.toString = (message) => typeof message === "string" ? message : message?.message;
+(function(errorUtil) {
+  errorUtil.errToObj = (message) => typeof message === "string" ? { message } : message || {};
+  errorUtil.toString = (message) => typeof message === "string" ? message : message?.message;
 })(errorUtil || (errorUtil = {}));
 
 // node_modules/zod/v3/types.js
@@ -2466,12 +2360,12 @@ var handleResult = (ctx, result) => {
 function processCreateParams(params) {
   if (!params)
     return {};
-  const { errorMap: errorMap2, invalid_type_error, required_error, description } = params;
-  if (errorMap2 && (invalid_type_error || required_error)) {
+  const { errorMap, invalid_type_error, required_error, description } = params;
+  if (errorMap && (invalid_type_error || required_error)) {
     throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
   }
-  if (errorMap2)
-    return { errorMap: errorMap2, description };
+  if (errorMap)
+    return { errorMap, description };
   const customMap = (iss, ctx) => {
     const { message } = params;
     if (iss.code === "invalid_enum_value") {
@@ -2858,11 +2752,11 @@ class ZodString extends ZodType {
     }
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.string) {
-      const ctx2 = this._getOrReturnCtx(input);
-      addIssueToContext(ctx2, {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.string,
-        received: ctx2.parsedType
+        received: ctx.parsedType
       });
       return INVALID;
     }
@@ -3416,11 +3310,11 @@ class ZodNumber extends ZodType {
     }
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.number) {
-      const ctx2 = this._getOrReturnCtx(input);
-      addIssueToContext(ctx2, {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.number,
-        received: ctx2.parsedType
+        received: ctx.parsedType
       });
       return INVALID;
     }
@@ -3842,17 +3736,17 @@ class ZodDate extends ZodType {
     }
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.date) {
-      const ctx2 = this._getOrReturnCtx(input);
-      addIssueToContext(ctx2, {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.date,
-        received: ctx2.parsedType
+        received: ctx.parsedType
       });
       return INVALID;
     }
     if (Number.isNaN(input.data.getTime())) {
-      const ctx2 = this._getOrReturnCtx(input);
-      addIssueToContext(ctx2, {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_date
       });
       return INVALID;
@@ -4140,8 +4034,8 @@ class ZodArray extends ZodType {
     if (ctx.common.async) {
       return Promise.all([...ctx.data].map((item, i) => {
         return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
-      })).then((result2) => {
-        return ParseStatus.mergeArray(status, result2);
+      })).then((result) => {
+        return ParseStatus.mergeArray(status, result);
       });
     }
     const result = [...ctx.data].map((item, i) => {
@@ -4222,18 +4116,18 @@ class ZodObject extends ZodType {
     if (this._cached !== null)
       return this._cached;
     const shape = this._def.shape();
-    const keys2 = util.objectKeys(shape);
-    this._cached = { shape, keys: keys2 };
+    const keys = util.objectKeys(shape);
+    this._cached = { shape, keys };
     return this._cached;
   }
   _parse(input) {
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.object) {
-      const ctx2 = this._getOrReturnCtx(input);
-      addIssueToContext(ctx2, {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.object,
-        received: ctx2.parsedType
+        received: ctx.parsedType
       });
       return INVALID;
     }
@@ -4537,7 +4431,7 @@ class ZodUnion extends ZodType {
         ctx.common.issues.push(...dirty.ctx.common.issues);
         return dirty.result;
       }
-      const unionErrors = issues.map((issues2) => new ZodError(issues2));
+      const unionErrors = issues.map((issues) => new ZodError(issues));
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_union,
         unionErrors
@@ -4977,9 +4871,9 @@ class ZodSet extends ZodType {
       }
     }
     const valueType = this._def.valueType;
-    function finalizeSet(elements2) {
+    function finalizeSet(elements) {
       const parsedSet = new Set;
-      for (const element of elements2) {
+      for (const element of elements) {
         if (element.status === "aborted")
           return INVALID;
         if (element.status === "dirty")
@@ -4990,7 +4884,7 @@ class ZodSet extends ZodType {
     }
     const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
     if (ctx.common.async) {
-      return Promise.all(elements).then((elements2) => finalizeSet(elements2));
+      return Promise.all(elements).then((elements) => finalizeSet(elements));
     } else {
       return finalizeSet(elements);
     }
@@ -5343,11 +5237,11 @@ class ZodEffects extends ZodType {
     if (effect.type === "preprocess") {
       const processed = effect.transform(ctx.data, checkCtx);
       if (ctx.common.async) {
-        return Promise.resolve(processed).then(async (processed2) => {
+        return Promise.resolve(processed).then(async (processed) => {
           if (status.value === "aborted")
             return INVALID;
           const result = await this._def.schema._parseAsync({
-            data: processed2,
+            data: processed,
             path: ctx.path,
             parent: ctx
           });
@@ -5539,10 +5433,10 @@ class ZodCatch extends ZodType {
       }
     });
     if (isAsync(result)) {
-      return result.then((result2) => {
+      return result.then((result) => {
         return {
           status: "valid",
-          value: result2.status === "valid" ? result2.value : this._def.catchValue({
+          value: result.status === "valid" ? result.value : this._def.catchValue({
             get error() {
               return new ZodError(newCtx.common.issues);
             },
@@ -5691,78 +5585,48 @@ ZodReadonly.create = (type, params) => {
     ...processCreateParams(params)
   });
 };
-function cleanParams(params, data) {
-  const p = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
-  const p2 = typeof p === "string" ? { message: p } : p;
-  return p2;
-}
-function custom(check, _params = {}, fatal) {
-  if (check)
-    return ZodAny.create().superRefine((data, ctx) => {
-      const r = check(data);
-      if (r instanceof Promise) {
-        return r.then((r2) => {
-          if (!r2) {
-            const params = cleanParams(_params, data);
-            const _fatal = params.fatal ?? fatal ?? true;
-            ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
-          }
-        });
-      }
-      if (!r) {
-        const params = cleanParams(_params, data);
-        const _fatal = params.fatal ?? fatal ?? true;
-        ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
-      }
-      return;
-    });
-  return ZodAny.create();
-}
 var late = {
   object: ZodObject.lazycreate
 };
 var ZodFirstPartyTypeKind;
-(function(ZodFirstPartyTypeKind2) {
-  ZodFirstPartyTypeKind2["ZodString"] = "ZodString";
-  ZodFirstPartyTypeKind2["ZodNumber"] = "ZodNumber";
-  ZodFirstPartyTypeKind2["ZodNaN"] = "ZodNaN";
-  ZodFirstPartyTypeKind2["ZodBigInt"] = "ZodBigInt";
-  ZodFirstPartyTypeKind2["ZodBoolean"] = "ZodBoolean";
-  ZodFirstPartyTypeKind2["ZodDate"] = "ZodDate";
-  ZodFirstPartyTypeKind2["ZodSymbol"] = "ZodSymbol";
-  ZodFirstPartyTypeKind2["ZodUndefined"] = "ZodUndefined";
-  ZodFirstPartyTypeKind2["ZodNull"] = "ZodNull";
-  ZodFirstPartyTypeKind2["ZodAny"] = "ZodAny";
-  ZodFirstPartyTypeKind2["ZodUnknown"] = "ZodUnknown";
-  ZodFirstPartyTypeKind2["ZodNever"] = "ZodNever";
-  ZodFirstPartyTypeKind2["ZodVoid"] = "ZodVoid";
-  ZodFirstPartyTypeKind2["ZodArray"] = "ZodArray";
-  ZodFirstPartyTypeKind2["ZodObject"] = "ZodObject";
-  ZodFirstPartyTypeKind2["ZodUnion"] = "ZodUnion";
-  ZodFirstPartyTypeKind2["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
-  ZodFirstPartyTypeKind2["ZodIntersection"] = "ZodIntersection";
-  ZodFirstPartyTypeKind2["ZodTuple"] = "ZodTuple";
-  ZodFirstPartyTypeKind2["ZodRecord"] = "ZodRecord";
-  ZodFirstPartyTypeKind2["ZodMap"] = "ZodMap";
-  ZodFirstPartyTypeKind2["ZodSet"] = "ZodSet";
-  ZodFirstPartyTypeKind2["ZodFunction"] = "ZodFunction";
-  ZodFirstPartyTypeKind2["ZodLazy"] = "ZodLazy";
-  ZodFirstPartyTypeKind2["ZodLiteral"] = "ZodLiteral";
-  ZodFirstPartyTypeKind2["ZodEnum"] = "ZodEnum";
-  ZodFirstPartyTypeKind2["ZodEffects"] = "ZodEffects";
-  ZodFirstPartyTypeKind2["ZodNativeEnum"] = "ZodNativeEnum";
-  ZodFirstPartyTypeKind2["ZodOptional"] = "ZodOptional";
-  ZodFirstPartyTypeKind2["ZodNullable"] = "ZodNullable";
-  ZodFirstPartyTypeKind2["ZodDefault"] = "ZodDefault";
-  ZodFirstPartyTypeKind2["ZodCatch"] = "ZodCatch";
-  ZodFirstPartyTypeKind2["ZodPromise"] = "ZodPromise";
-  ZodFirstPartyTypeKind2["ZodBranded"] = "ZodBranded";
-  ZodFirstPartyTypeKind2["ZodPipeline"] = "ZodPipeline";
-  ZodFirstPartyTypeKind2["ZodReadonly"] = "ZodReadonly";
+(function(ZodFirstPartyTypeKind) {
+  ZodFirstPartyTypeKind["ZodString"] = "ZodString";
+  ZodFirstPartyTypeKind["ZodNumber"] = "ZodNumber";
+  ZodFirstPartyTypeKind["ZodNaN"] = "ZodNaN";
+  ZodFirstPartyTypeKind["ZodBigInt"] = "ZodBigInt";
+  ZodFirstPartyTypeKind["ZodBoolean"] = "ZodBoolean";
+  ZodFirstPartyTypeKind["ZodDate"] = "ZodDate";
+  ZodFirstPartyTypeKind["ZodSymbol"] = "ZodSymbol";
+  ZodFirstPartyTypeKind["ZodUndefined"] = "ZodUndefined";
+  ZodFirstPartyTypeKind["ZodNull"] = "ZodNull";
+  ZodFirstPartyTypeKind["ZodAny"] = "ZodAny";
+  ZodFirstPartyTypeKind["ZodUnknown"] = "ZodUnknown";
+  ZodFirstPartyTypeKind["ZodNever"] = "ZodNever";
+  ZodFirstPartyTypeKind["ZodVoid"] = "ZodVoid";
+  ZodFirstPartyTypeKind["ZodArray"] = "ZodArray";
+  ZodFirstPartyTypeKind["ZodObject"] = "ZodObject";
+  ZodFirstPartyTypeKind["ZodUnion"] = "ZodUnion";
+  ZodFirstPartyTypeKind["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
+  ZodFirstPartyTypeKind["ZodIntersection"] = "ZodIntersection";
+  ZodFirstPartyTypeKind["ZodTuple"] = "ZodTuple";
+  ZodFirstPartyTypeKind["ZodRecord"] = "ZodRecord";
+  ZodFirstPartyTypeKind["ZodMap"] = "ZodMap";
+  ZodFirstPartyTypeKind["ZodSet"] = "ZodSet";
+  ZodFirstPartyTypeKind["ZodFunction"] = "ZodFunction";
+  ZodFirstPartyTypeKind["ZodLazy"] = "ZodLazy";
+  ZodFirstPartyTypeKind["ZodLiteral"] = "ZodLiteral";
+  ZodFirstPartyTypeKind["ZodEnum"] = "ZodEnum";
+  ZodFirstPartyTypeKind["ZodEffects"] = "ZodEffects";
+  ZodFirstPartyTypeKind["ZodNativeEnum"] = "ZodNativeEnum";
+  ZodFirstPartyTypeKind["ZodOptional"] = "ZodOptional";
+  ZodFirstPartyTypeKind["ZodNullable"] = "ZodNullable";
+  ZodFirstPartyTypeKind["ZodDefault"] = "ZodDefault";
+  ZodFirstPartyTypeKind["ZodCatch"] = "ZodCatch";
+  ZodFirstPartyTypeKind["ZodPromise"] = "ZodPromise";
+  ZodFirstPartyTypeKind["ZodBranded"] = "ZodBranded";
+  ZodFirstPartyTypeKind["ZodPipeline"] = "ZodPipeline";
+  ZodFirstPartyTypeKind["ZodReadonly"] = "ZodReadonly";
 })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
-var instanceOfType = (cls, params = {
-  message: `Input not instance of ${cls.name}`
-}) => custom((data) => data instanceof cls, params);
 var stringType = ZodString.create;
 var numberType = ZodNumber.create;
 var nanType = ZodNaN.create;
@@ -5797,64 +5661,50 @@ var optionalType = ZodOptional.create;
 var nullableType = ZodNullable.create;
 var preprocessType = ZodEffects.createWithPreprocess;
 var pipelineType = ZodPipeline.create;
-var ostring = () => stringType().optional();
-var onumber = () => numberType().optional();
-var oboolean = () => booleanType().optional();
-var coerce = {
-  string: (arg) => ZodString.create({ ...arg, coerce: true }),
-  number: (arg) => ZodNumber.create({ ...arg, coerce: true }),
-  boolean: (arg) => ZodBoolean.create({
-    ...arg,
-    coerce: true
-  }),
-  bigint: (arg) => ZodBigInt.create({ ...arg, coerce: true }),
-  date: (arg) => ZodDate.create({ ...arg, coerce: true })
-};
-var NEVER = INVALID;
 // src/schemas.ts
 var nullToUndefined = (v) => v ?? undefined;
-var optionalString = exports_external.string().nullish().transform(nullToUndefined);
-var ratingDistributionSchema = exports_external.object({
-  average_rating: exports_external.number(),
-  display_average_rating: exports_external.string().default("0"),
-  display_stars: exports_external.number().default(0),
-  num_ratings: exports_external.number(),
-  num_five_star_ratings: exports_external.number().default(0),
-  num_four_star_ratings: exports_external.number().default(0),
-  num_three_star_ratings: exports_external.number().default(0),
-  num_two_star_ratings: exports_external.number().default(0),
-  num_one_star_ratings: exports_external.number().default(0)
+var optionalString = stringType().nullish().transform(nullToUndefined);
+var ratingDistributionSchema = objectType({
+  average_rating: numberType(),
+  display_average_rating: stringType().default("0"),
+  display_stars: numberType().default(0),
+  num_ratings: numberType(),
+  num_five_star_ratings: numberType().default(0),
+  num_four_star_ratings: numberType().default(0),
+  num_three_star_ratings: numberType().default(0),
+  num_two_star_ratings: numberType().default(0),
+  num_one_star_ratings: numberType().default(0)
 });
-var audibleRatingSchema = exports_external.object({
-  num_reviews: exports_external.number().default(0),
+var audibleRatingSchema = objectType({
+  num_reviews: numberType().default(0),
   overall_distribution: ratingDistributionSchema.nullish(),
   performance_distribution: ratingDistributionSchema.nullish(),
   story_distribution: ratingDistributionSchema.nullish()
 }).nullish();
-var categoryLadderSchema = exports_external.object({
-  root: exports_external.string().default("Genres"),
-  ladder: exports_external.array(exports_external.object({
-    id: exports_external.string(),
-    name: exports_external.string()
+var categoryLadderSchema = objectType({
+  root: stringType().default("Genres"),
+  ladder: arrayType(objectType({
+    id: stringType(),
+    name: stringType()
   })).default([])
 });
-var relationshipSchema = exports_external.object({
-  asin: exports_external.string(),
+var relationshipSchema = objectType({
+  asin: stringType(),
   relationship_to_product: optionalString,
   relationship_type: optionalString,
   title: optionalString,
   sort: optionalString,
   url: optionalString
 });
-var audibleRawItemSchema = exports_external.object({
-  asin: exports_external.string().min(1),
-  title: exports_external.string().min(1),
+var audibleRawItemSchema = objectType({
+  asin: stringType().min(1),
+  title: stringType().min(1),
   subtitle: optionalString,
   isbn: optionalString,
   sku: optionalString,
-  authors: exports_external.array(exports_external.object({ name: exports_external.string() })).default([]),
-  narrators: exports_external.array(exports_external.object({ name: exports_external.string() })).default([]),
-  runtime_length_min: exports_external.number().nonnegative().default(0),
+  authors: arrayType(objectType({ name: stringType() })).default([]),
+  narrators: arrayType(objectType({ name: stringType() })).default([]),
+  runtime_length_min: numberType().nonnegative().default(0),
   publisher_name: optionalString,
   language: optionalString,
   release_date: optionalString,
@@ -5866,29 +5716,29 @@ var audibleRawItemSchema = exports_external.object({
   content_type: optionalString,
   content_delivery_type: optionalString,
   program_participation: optionalString,
-  product_images: exports_external.record(exports_external.string(), exports_external.string()).nullish().transform((v) => v ?? {}),
-  social_media_images: exports_external.record(exports_external.string(), exports_external.string()).nullish().transform((v) => v ?? {}),
-  series: exports_external.array(exports_external.object({
-    asin: exports_external.string(),
-    title: exports_external.string(),
+  product_images: recordType(stringType(), stringType()).nullish().transform((v) => v ?? {}),
+  social_media_images: recordType(stringType(), stringType()).nullish().transform((v) => v ?? {}),
+  series: arrayType(objectType({
+    asin: stringType(),
+    title: stringType(),
     sequence: optionalString
   })).nullish().transform((v) => v ?? []),
-  category_ladders: exports_external.array(categoryLadderSchema).nullish().transform((v) => v ?? []),
-  platinum_keywords: exports_external.array(exports_external.string()).nullish().transform((v) => v ?? []),
-  thesaurus_subject_keywords: exports_external.array(exports_external.string()).nullish().transform((v) => v ?? []),
+  category_ladders: arrayType(categoryLadderSchema).nullish().transform((v) => v ?? []),
+  platinum_keywords: arrayType(stringType()).nullish().transform((v) => v ?? []),
+  thesaurus_subject_keywords: arrayType(stringType()).nullish().transform((v) => v ?? []),
   rating: audibleRatingSchema,
-  listening_status: exports_external.object({
-    is_finished: exports_external.boolean().optional(),
-    percent_complete: exports_external.number().optional(),
-    finished_at_timestamp: exports_external.string().nullish(),
-    time_remaining_seconds: exports_external.number().optional()
+  listening_status: objectType({
+    is_finished: booleanType().optional(),
+    percent_complete: numberType().optional(),
+    finished_at_timestamp: stringType().nullish(),
+    time_remaining_seconds: numberType().optional()
   }).nullish().transform(nullToUndefined),
   purchase_date: optionalString,
-  library_status: exports_external.object({
-    date_added: exports_external.string().nullish()
+  library_status: objectType({
+    date_added: stringType().nullish()
   }).nullish().transform(nullToUndefined),
-  relationships: exports_external.array(relationshipSchema).nullish().transform((v) => v ?? []),
-  is_adult_product: exports_external.boolean().nullish().transform((v) => v ?? false)
+  relationships: arrayType(relationshipSchema).nullish().transform((v) => v ?? []),
+  is_adult_product: booleanType().nullish().transform((v) => v ?? false)
 });
 
 // src/signing.ts
@@ -6038,14 +5888,14 @@ var catalog = async (credentials, options) => {
   const limit = options.limit ?? 50;
   if (sortBy === "MostVoted") {
     const MAX_PAGES = 20;
-    const { items: allItems, credentials: fresh2 } = await fetchCatalogPages(credentials, categoryId, options, MAX_PAGES);
+    const { items: allItems, credentials: fresh } = await fetchCatalogPages(credentials, categoryId, options, MAX_PAGES);
     const sorted = orderBy_default(uniqBy_default(allItems, ({ asin }) => asin), [
       ({ rating }) => rating?.overallDistribution?.numRatings ?? 0,
       ({ rating }) => rating?.overallDistribution?.averageRating ?? 0
     ], ["desc", "desc"]);
     return {
       items: limit === "all" ? sorted : sorted.slice(0, limit),
-      credentials: fresh2
+      credentials: fresh
     };
   }
   const { data: response, credentials: fresh } = await audibleFetch("/catalog/products", credentials, {
@@ -6072,14 +5922,14 @@ var verify = async (credentials) => {
   });
 };
 export {
-  wishlist,
-  verify,
-  resolveGenreId,
-  register,
-  refresh,
-  login,
-  library,
-  catalog,
+  AUDIBLE_LOCALES,
   GENRE_CATEGORIES,
-  AUDIBLE_LOCALES
+  catalog,
+  library,
+  login,
+  refresh,
+  register,
+  resolveGenreId,
+  verify,
+  wishlist
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "audible-api-ts",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "A fully typed TypeScript client for the Audible API — authentication, library, wishlist, and catalog search",
   "type": "module",
   "main": "./dist/index.js",