@brigadasos/nadeshiko-sdk 1.4.3-dev.0ffbf39 → 1.4.3-dev.2ba18e0

package/dist/types.gen.d.ts

@@ -1,5 +1,5 @@
 export type ClientOptions = {
-    baseUrl: 'http://localhost:5000' | 'https://api.nadeshiko.co' | (string & {});
+    baseUrl: 'https://api.nadeshiko.co' | (string & {});
 };
 /**
  * A media filter entry with optional episode restriction
@@ -77,6 +77,15 @@ export type SearchFilters = {
          */
         max?: number;
     };
+    /**
+     * Language inclusion/exclusion for search matching
+     */
+    languages?: {
+        /**
+         * Language codes to exclude from search matching (e.g., ["en"], ["es"], ["en","es"])
+         */
+        exclude?: Array<'en' | 'es'>;
+    };
 };
 /**
  * Resource to expand in the response includes block
@@ -99,11 +108,11 @@ export type SearchRequest = {
     /**
      * Max amount of entries by response
      */
-    limit?: number;
+    take?: number;
     /**
-     * Current page of search
+     * Opaque cursor token returned from the previous search page
      */
-    cursor?: Array<number>;
+    cursor?: string;
     /**
      * Sort configuration
      */
@@ -238,9 +247,10 @@ export type ExternalId = {
  */
 export type Seiyuu = {
     /**
-     * AniList staff ID
+     * Internal seiyuu ID
      */
     id: number;
+    externalIds: ExternalId;
     /**
      * Japanese name of the voice actor
      */
@@ -362,31 +372,31 @@ export type PaginationInfo = {
     /**
      * Whether there are more results after this page
      */
-    hasMore?: boolean;
+    hasMore: boolean;
     /**
      * Estimated total number of matching segments
      */
-    estimatedTotalHits?: number;
+    estimatedTotalHits: number;
     /**
      * Whether estimatedTotalHits is exact or a lower bound
      */
-    estimatedTotalHitsRelation?: 'EXACT' | 'LOWER_BOUND';
+    estimatedTotalHitsRelation: 'EXACT' | 'LOWER_BOUND';
     /**
-     * Cursor for fetching the next page (undefined when hasMore is false)
+     * Opaque cursor token for fetching the next page (`null` when hasMore is false)
      */
-    cursor?: Array<number>;
+    cursor: string;
 };
 export type SearchResponse = {
-    segments?: Array<Segment>;
-    includes?: {
+    segments: Array<Segment>;
+    includes: {
         /**
          * Media objects keyed by mediaId
          */
-        media?: {
+        media: {
             [key: string]: Media;
         };
     };
-    pagination?: PaginationInfo;
+    pagination: PaginationInfo;
 };
 /**
  * Bad Request error response
@@ -606,20 +616,20 @@ export type MediaSearchStats = {
  * Count of entries grouped by media category
  */
 export type CategoryCount = {
-    category?: Category;
+    category: Category;
     /**
      * Number of entries in this category
      */
-    count?: number;
+    count: number;
 };
 export type SearchStatsResponse = {
-    media?: Array<MediaSearchStats>;
-    categories?: Array<CategoryCount>;
-    includes?: {
+    media: Array<MediaSearchStats>;
+    categories: Array<CategoryCount>;
+    includes: {
         /**
          * Media objects keyed by mediaId
          */
-        media?: {
+        media: {
             [key: string]: Media;
         };
     };
@@ -664,27 +674,27 @@ export type WordMatch = {
     /**
      * The word that was searched for
      */
-    word?: string;
+    word: string;
     /**
      * Indicates whether the word was found in any segment
      */
-    isMatch?: boolean;
+    isMatch: boolean;
     /**
      * Total number of times this word appears across all media
      */
-    matchCount?: number;
+    matchCount: number;
     /**
      * List of media containing this word
      */
-    media?: Array<WordMatchMedia>;
+    media: Array<WordMatchMedia>;
 };
 export type SearchMultipleResponse = {
-    results?: Array<WordMatch>;
-    includes?: {
+    results: Array<WordMatch>;
+    includes: {
         /**
          * Media objects keyed by mediaId
          */
-        media?: {
+        media: {
             [key: string]: Media;
         };
     };
@@ -692,32 +702,29 @@ export type SearchMultipleResponse = {
 /**
  * Resource to expand in media responses
  */
-export type MediaIncludeExpansion = 'media' | 'media.characters';
+export type MediaIncludeExpansion = 'media.characters';
 /**
- * Cursor pagination metadata
+ * Opaque cursor pagination metadata
  */
-export type CursorPagination = {
+export type OpaqueCursorPagination = {
     /**
      * Whether more results are available
      */
     hasMore: boolean;
     /**
-     * Cursor for the next page (`null` when `hasMore` is `false`)
+     * Opaque token for the next page (`null` when `hasMore` is `false`)
      */
-    cursor: number;
+    cursor: string;
 };
 export type MediaListResponse = {
     media: Array<Media>;
-    pagination: CursorPagination;
+    pagination: OpaqueCursorPagination;
 };
 /**
  * Character data for creating/updating media
  */
 export type CharacterInput = {
-    /**
-     * AniList character ID
-     */
-    id: number;
+    externalIds: ExternalId;
     /**
      * Japanese name of the character
      */
@@ -734,22 +741,21 @@ export type CharacterInput = {
      * Character's role in the media
      */
     role: 'MAIN' | 'SUPPORTING' | 'BACKGROUND';
-    /**
-     * AniList staff ID for the Japanese voice actor
-     */
-    seiyuuId: number;
-    /**
-     * Japanese name of the voice actor
-     */
-    seiyuuNameJa: string;
-    /**
-     * English name of the voice actor
-     */
-    seiyuuNameEn: string;
-    /**
-     * Voice actor profile image URL
-     */
-    seiyuuImageUrl: string;
+    seiyuu: {
+        externalIds: ExternalId;
+        /**
+         * Japanese name of the voice actor
+         */
+        nameJa: string;
+        /**
+         * English name of the voice actor
+         */
+        nameEn: string;
+        /**
+         * Voice actor profile image URL
+         */
+        imageUrl: string;
+    };
 };
 /**
  * Request body for creating a new media entry
@@ -860,6 +866,9 @@ export type Error409 = {
         [key: string]: string;
     };
 };
+export type MediaAutocompleteResponse = {
+    media: Array<Media>;
+};
 /**
  * Not Found error response
  */
@@ -895,205 +904,14 @@ export type Error404 = {
         [key: string]: string;
     };
 };
-/**
- * Request body for updating an existing media entry (all fields optional)
- */
-export type MediaUpdateRequest = {
-    externalIds?: ExternalId;
-    /**
-     * Original Japanese name of the media
-     */
-    nameJa?: string;
-    /**
-     * Romaji transliteration of the media name
-     */
-    nameRomaji?: string;
-    /**
-     * English name of the media
-     */
-    nameEn?: string;
-    /**
-     * Format of the media release (e.g., TV, OVA, Movie)
-     */
-    airingFormat?: string;
-    /**
-     * Current airing status (FINISHED, RELEASING, NOT_YET_RELEASED, CANCELLED)
-     */
-    airingStatus?: string;
-    /**
-     * List of genres associated with the media
-     */
-    genres?: Array<string>;
-    /**
-     * Storage backend for media assets
-     */
-    storage?: 'LOCAL' | 'R2';
-    /**
-     * Start date of the media (first airing/release)
-     */
-    startDate?: string;
-    /**
-     * End date of the media (last airing/release)
-     */
-    endDate?: string;
-    /**
-     * Media category
-     */
-    category?: 'ANIME' | 'JDRAMA';
-    /**
-     * Version of the media-sub-splitter used
-     */
-    version?: string;
-    /**
-     * Hash salt used when generating the hash for the related media assets
-     */
-    hashSalt?: string;
-    /**
-     * Animation studio that produced the media
-     */
-    studio?: string;
-    /**
-     * Airing season label for the media
-     */
-    seasonName?: string;
-    /**
-     * Airing year for the media
-     */
-    seasonYear?: number;
-    /**
-     * Base path for R2/CDN storage (e.g. "media/21459")
-     */
-    storageBasePath?: string;
-    /**
-     * List of characters appearing in the media with their voice actors
-     */
-    characters?: Array<CharacterInput>;
-    /**
-     * Total number of subtitle segments available
-     */
-    segmentCount?: number;
-};
-export type Episode = {
-    /**
-     * ID of the media this episode belongs to
-     */
-    mediaId: number;
-    /**
-     * Episode number within the media
-     */
-    episodeNumber: number;
-    /**
-     * English title of the episode
-     */
-    titleEn?: string;
-    /**
-     * Romanized title of the episode
-     */
-    titleRomaji?: string;
-    /**
-     * Japanese title of the episode
-     */
-    titleJa?: string;
-    /**
-     * Episode description or synopsis
-     */
-    description?: string;
-    /**
-     * When the episode originally aired
-     */
-    airedAt?: string;
-    /**
-     * Episode duration in seconds
-     */
-    lengthSeconds?: number;
-    /**
-     * URL to episode thumbnail image
-     */
-    thumbnailUrl?: string;
-    /**
-     * Number of segments in this episode
-     */
-    segmentCount: number;
-};
-export type EpisodeListResponse = {
-    /**
-     * Array of episode objects
-     */
-    episodes: Array<Episode>;
-    pagination: CursorPagination;
-};
-export type EpisodeCreateRequest = {
-    /**
-     * English title of the episode
-     */
-    titleEn?: string;
-    /**
-     * Romanized title of the episode
-     */
-    titleRomaji?: string;
-    /**
-     * Japanese title of the episode
-     */
-    titleJa?: string;
-    /**
-     * Episode description or synopsis
-     */
-    description?: string;
-    /**
-     * When the episode originally aired
-     */
-    airedAt?: string;
-    /**
-     * Episode duration in seconds
-     */
-    lengthSeconds?: number;
-    /**
-     * URL to episode thumbnail image
-     */
-    thumbnailUrl?: string;
-    /**
-     * Episode number within the media (must be unique for this media)
-     */
-    episodeNumber: number;
-};
 /**
  * All fields are optional for partial updates
  */
-export type EpisodeUpdateRequest = {
-    /**
-     * English title of the episode
-     */
-    titleEn?: string;
-    /**
-     * Romanized title of the episode
-     */
-    titleRomaji?: string;
-    /**
-     * Japanese title of the episode
-     */
-    titleJa?: string;
-    /**
-     * Episode description or synopsis
-     */
-    description?: string;
-    /**
-     * When the episode originally aired
-     */
-    airedAt?: string;
-    /**
-     * Episode duration in seconds
-     */
-    lengthSeconds?: number;
-    /**
-     * URL to episode thumbnail image
-     */
-    thumbnailUrl?: string;
-};
-export type SegmentCreateRequest = {
+export type SegmentUpdateRequest = {
     /**
      * Position of the segment within the episode
      */
-    position: number;
+    position?: number;
     /**
      * Segment status
      */
@@ -1101,12 +919,12 @@ export type SegmentCreateRequest = {
     /**
      * Start time of the segment in milliseconds from the beginning of the episode
      */
-    startTimeMs: number;
+    startTimeMs?: number;
     /**
      * End time of the segment in milliseconds from the beginning of the episode
      */
-    endTimeMs: number;
-    textJa: {
+    endTimeMs?: number;
+    textJa?: {
         /**
          * Original Japanese content of the segment
          */
@@ -1148,11 +966,11 @@ export type SegmentCreateRequest = {
     /**
      * Storage backend for segment assets
      */
-    storage: 'LOCAL' | 'R2';
+    storage?: 'LOCAL' | 'R2';
     /**
      * Hash identifier for the segment (from segment JSON)
      */
-    hashedId: string;
+    hashedId?: string;
 };
 /**
  * Segment with internal fields (for internal API responses)
@@ -1161,99 +979,31 @@ export type SegmentInternal = Segment & {
     /**
      * Storage backend for segment assets
      */
-    storage?: 'LOCAL' | 'R2';
+    storage: 'LOCAL' | 'R2';
     /**
      * Hash identifier for the segment
      */
-    hashedId?: string;
+    hashedId: string;
     /**
      * Base path in the storage backend
      */
-    storageBasePath?: string;
+    storageBasePath: string;
     /**
      * Raw WD Tagger v3 classifier output used to derive content rating
      */
-    ratingAnalysis?: {
+    ratingAnalysis: {
         [key: string]: unknown;
     };
     /**
      * POS tokenization results keyed by engine (sudachi, unidic)
      */
-    posAnalysis?: {
+    posAnalysis: {
         [key: string]: unknown;
     };
 };
-/**
- * All fields are optional for partial updates
- */
-export type SegmentUpdateRequest = {
-    /**
-     * Position of the segment within the episode
-     */
-    position?: number;
-    /**
-     * Segment status
-     */
-    status?: 'DELETED' | 'ACTIVE' | 'SUSPENDED' | 'VERIFIED' | 'INVALID' | 'TOO_LONG';
-    /**
-     * Start time of the segment in milliseconds from the beginning of the episode
-     */
-    startTimeMs?: number;
-    /**
-     * End time of the segment in milliseconds from the beginning of the episode
-     */
-    endTimeMs?: number;
-    textJa?: {
-        /**
-         * Original Japanese content of the segment
-         */
-        content?: string;
-    };
-    textEs?: {
-        /**
-         * Spanish translation of the segment content
-         */
-        content?: string;
-        /**
-         * Whether the Spanish translation was machine-translated
-         */
-        isMachineTranslated?: boolean;
-    };
-    textEn?: {
-        /**
-         * English translation of the segment content
-         */
-        content?: string;
-        /**
-         * Whether the English translation was machine-translated
-         */
-        isMachineTranslated?: boolean;
-    };
-    contentRating?: ContentRating;
-    /**
-     * Raw WD Tagger v3 classifier output used to derive content rating
-     */
-    ratingAnalysis?: {
-        [key: string]: unknown;
-    };
-    /**
-     * POS tokenization results keyed by engine (sudachi, unidic)
-     */
-    posAnalysis?: {
-        [key: string]: unknown;
-    };
-    /**
-     * Storage backend for segment assets
-     */
-    storage?: 'LOCAL' | 'R2';
-    /**
-     * Hash identifier for the segment (from segment JSON)
-     */
-    hashedId?: string;
-};
 export type SegmentContextResponse = {
     segments: Array<Segment>;
-    includes?: {
+    includes: {
         /**
          * Media objects keyed by mediaId
          */
@@ -1285,7 +1035,7 @@ export type Series = {
 };
 export type SeriesListResponse = {
     series: Array<Series>;
-    pagination: CursorPagination;
+    pagination: OpaqueCursorPagination;
 };
 /**
  * Series with ordered media entries
@@ -1314,8 +1064,8 @@ export type SeriesWithMedia = {
         /**
          * Position in the series (1-indexed)
          */
-        position?: number;
-        media?: Media;
+        position: number;
+        media: Media;
     }>;
 };
 /**
@@ -1323,9 +1073,10 @@ export type SeriesWithMedia = {
  */
 export type Character = {
     /**
-     * AniList character ID
+     * Internal character ID
      */
     id: number;
+    externalIds: ExternalId;
     /**
      * Japanese name of the character
      */
@@ -1348,11 +1099,11 @@ export type CharacterWithMedia = Character & {
      * All media this character appears in
      */
     mediaAppearances: Array<{
-        media?: Media;
+        media: Media;
         /**
          * Character role in this media
          */
-        role?: 'MAIN' | 'SUPPORTING' | 'BACKGROUND';
+        role: 'MAIN' | 'SUPPORTING' | 'BACKGROUND';
     }>;
 };
 /**
@@ -1363,28 +1114,288 @@ export type SeiyuuWithRoles = {
      * AniList staff ID
      */
     id: number;
+    externalIds: ExternalId;
     /**
      * Japanese name of the voice actor
      */
     nameJa: string;
     /**
-     * English name of the voice actor
+     * English name of the voice actor
+     */
+    nameEn: string;
+    /**
+     * Profile image URL
+     */
+    imageUrl: string;
+    /**
+     * Characters voiced by this seiyuu with their media appearances
+     */
+    characters: Array<Character & {
+        media: Media;
+        /**
+         * Character role in this media
+         */
+        role: 'MAIN' | 'SUPPORTING' | 'BACKGROUND';
+    }>;
+};
+/**
+ * Request body for updating an existing media entry (all fields optional)
+ */
+export type MediaUpdateRequest = {
+    externalIds?: ExternalId;
+    /**
+     * Original Japanese name of the media
+     */
+    nameJa?: string;
+    /**
+     * Romaji transliteration of the media name
+     */
+    nameRomaji?: string;
+    /**
+     * English name of the media
+     */
+    nameEn?: string;
+    /**
+     * Format of the media release (e.g., TV, OVA, Movie)
+     */
+    airingFormat?: string;
+    /**
+     * Current airing status (FINISHED, RELEASING, NOT_YET_RELEASED, CANCELLED)
+     */
+    airingStatus?: string;
+    /**
+     * List of genres associated with the media
+     */
+    genres?: Array<string>;
+    /**
+     * Storage backend for media assets
+     */
+    storage?: 'LOCAL' | 'R2';
+    /**
+     * Start date of the media (first airing/release)
+     */
+    startDate?: string;
+    /**
+     * End date of the media (last airing/release)
+     */
+    endDate?: string;
+    /**
+     * Media category
+     */
+    category?: 'ANIME' | 'JDRAMA';
+    /**
+     * Version of the media-sub-splitter used
+     */
+    version?: string;
+    /**
+     * Hash salt used when generating the hash for the related media assets
+     */
+    hashSalt?: string;
+    /**
+     * Animation studio that produced the media
+     */
+    studio?: string;
+    /**
+     * Airing season label for the media
+     */
+    seasonName?: string;
+    /**
+     * Airing year for the media
+     */
+    seasonYear?: number;
+    /**
+     * Base path for R2/CDN storage (e.g. "media/21459")
+     */
+    storageBasePath?: string;
+    /**
+     * List of characters appearing in the media with their voice actors
+     */
+    characters?: Array<CharacterInput>;
+    /**
+     * Total number of subtitle segments available
+     */
+    segmentCount?: number;
+};
+export type Episode = {
+    /**
+     * ID of the media this episode belongs to
+     */
+    mediaId: number;
+    /**
+     * Episode number within the media
+     */
+    episodeNumber: number;
+    /**
+     * English title of the episode
+     */
+    titleEn?: string;
+    /**
+     * Romanized title of the episode
+     */
+    titleRomaji?: string;
+    /**
+     * Japanese title of the episode
+     */
+    titleJa?: string;
+    /**
+     * Episode description or synopsis
+     */
+    description?: string;
+    /**
+     * When the episode originally aired
+     */
+    airedAt?: string;
+    /**
+     * Episode duration in seconds
+     */
+    lengthSeconds?: number;
+    /**
+     * URL to episode thumbnail image
+     */
+    thumbnailUrl?: string;
+    /**
+     * Number of segments in this episode
+     */
+    segmentCount: number;
+};
+export type EpisodeListResponse = {
+    /**
+     * Array of episode objects
+     */
+    episodes: Array<Episode>;
+    pagination: OpaqueCursorPagination;
+};
+export type EpisodeCreateRequest = {
+    /**
+     * English title of the episode
+     */
+    titleEn?: string;
+    /**
+     * Romanized title of the episode
+     */
+    titleRomaji?: string;
+    /**
+     * Japanese title of the episode
+     */
+    titleJa?: string;
+    /**
+     * Episode description or synopsis
+     */
+    description?: string;
+    /**
+     * When the episode originally aired
+     */
+    airedAt?: string;
+    /**
+     * Episode duration in seconds
+     */
+    lengthSeconds?: number;
+    /**
+     * URL to episode thumbnail image
+     */
+    thumbnailUrl?: string;
+    /**
+     * Episode number within the media (must be unique for this media)
+     */
+    episodeNumber: number;
+};
+/**
+ * All fields are optional for partial updates
+ */
+export type EpisodeUpdateRequest = {
+    /**
+     * English title of the episode
+     */
+    titleEn?: string;
+    /**
+     * Romanized title of the episode
+     */
+    titleRomaji?: string;
+    /**
+     * Japanese title of the episode
+     */
+    titleJa?: string;
+    /**
+     * Episode description or synopsis
+     */
+    description?: string;
+    /**
+     * When the episode originally aired
+     */
+    airedAt?: string;
+    /**
+     * Episode duration in seconds
+     */
+    lengthSeconds?: number;
+    /**
+     * URL to episode thumbnail image
+     */
+    thumbnailUrl?: string;
+};
+export type SegmentCreateRequest = {
+    /**
+     * Position of the segment within the episode
+     */
+    position: number;
+    /**
+     * Segment status
+     */
+    status?: 'DELETED' | 'ACTIVE' | 'SUSPENDED' | 'VERIFIED' | 'INVALID' | 'TOO_LONG';
+    /**
+     * Start time of the segment in milliseconds from the beginning of the episode
+     */
+    startTimeMs: number;
+    /**
+     * End time of the segment in milliseconds from the beginning of the episode
+     */
+    endTimeMs: number;
+    textJa: {
+        /**
+         * Original Japanese content of the segment
+         */
+        content?: string;
+    };
+    textEs?: {
+        /**
+         * Spanish translation of the segment content
+         */
+        content?: string;
+        /**
+         * Whether the Spanish translation was machine-translated
+         */
+        isMachineTranslated?: boolean;
+    };
+    textEn?: {
+        /**
+         * English translation of the segment content
+         */
+        content?: string;
+        /**
+         * Whether the English translation was machine-translated
+         */
+        isMachineTranslated?: boolean;
+    };
+    contentRating?: ContentRating;
+    /**
+     * Raw WD Tagger v3 classifier output used to derive content rating
+     */
+    ratingAnalysis?: {
+        [key: string]: unknown;
+    };
+    /**
+     * POS tokenization results keyed by engine (sudachi, unidic)
      */
-    nameEn: string;
+    posAnalysis?: {
+        [key: string]: unknown;
+    };
     /**
-     * Profile image URL
+     * Storage backend for segment assets
      */
-    imageUrl: string;
+    storage: 'LOCAL' | 'R2';
     /**
-     * Characters voiced by this seiyuu with their media appearances
+     * Hash identifier for the segment (from segment JSON)
      */
-    characters: Array<Character & {
-        media: Media;
-        /**
-         * Character role in this media
-         */
-        role: 'MAIN' | 'SUPPORTING' | 'BACKGROUND';
-    }>;
+    hashedId: string;
 };
 export type UserQuotaResponse = {
     /**
@@ -1422,37 +1433,53 @@ export type ReportTargetMedia = {
      */
     mediaId: number;
 };
-export type ReportTargetEpisode = {
+export type ReportTargetSegment = {
     /**
      * Report target type
      */
-    type: 'EPISODE';
+    type: 'SEGMENT';
     /**
      * Media ID this report targets
      */
     mediaId: number;
     /**
-     * Episode number this report targets
+     * Episode number containing the segment
      */
-    episodeNumber: number;
+    episodeNumber?: number;
+    /**
+     * Segment UUID this report targets
+     */
+    segmentUuid: string;
 };
-export type ReportTargetSegment = {
+export type UserReportTarget = ({
+    type: 'MEDIA';
+} & ReportTargetMedia) | ({
+    type: 'SEGMENT';
+} & ReportTargetSegment);
+export type CreateReportRequest = {
+    target: UserReportTarget;
+    /**
+     * Reason for the report
+     */
+    reason: 'WRONG_TRANSLATION' | 'WRONG_TIMING' | 'WRONG_AUDIO' | 'NSFW_NOT_TAGGED' | 'DUPLICATE_SEGMENT' | 'WRONG_METADATA' | 'MISSING_EPISODES' | 'WRONG_COVER_IMAGE' | 'INAPPROPRIATE_CONTENT' | 'OTHER';
+    /**
+     * Optional description with additional details
+     */
+    description?: string;
+};
+export type ReportTargetEpisode = {
     /**
      * Report target type
      */
-    type: 'SEGMENT';
+    type: 'EPISODE';
     /**
      * Media ID this report targets
      */
     mediaId: number;
     /**
-     * Episode number containing the segment
-     */
-    episodeNumber?: number;
-    /**
-     * Segment UUID this report targets
+     * Episode number this report targets
      */
-    segmentUuid: string;
+    episodeNumber: number;
 };
 export type ReportTarget = ({
     type: 'MEDIA';
@@ -1472,9 +1499,9 @@ export type Report = {
     source: 'USER' | 'AUTO';
     target: ReportTarget;
     /**
-     * ID of the auto-check run that created this report (AUTO only)
+     * ID of the audit run that created this report (AUTO only)
      */
-    reviewCheckRunId?: number;
+    auditRunId: number;
     /**
      * Reason for the report
      */
@@ -1482,11 +1509,11 @@ export type Report = {
     /**
      * Optional description with additional details
      */
-    description?: string;
+    description: string;
     /**
      * Check-specific metrics (AUTO reports) or null (USER reports)
      */
-    data?: {
+    data: {
         [key: string]: unknown;
     };
     /**
@@ -1496,11 +1523,11 @@ export type Report = {
     /**
      * Notes from the admin who reviewed the report
      */
-    adminNotes?: string;
+    adminNotes: string;
     /**
      * ID of the user who submitted the report (USER reports only)
      */
-    userId?: number;
+    userId: number;
     /**
      * When the report was created
      */
@@ -1508,35 +1535,9 @@ export type Report = {
     /**
      * When the report was last updated
      */
-    updatedAt?: string;
-};
-export type ReportListResponse = {
-    reports: Array<Report>;
-    pagination: CursorPagination;
-};
-export type UserReportTarget = ({
-    type: 'MEDIA';
-} & ReportTargetMedia) | ({
-    type: 'SEGMENT';
-} & ReportTargetSegment);
-export type CreateReportRequest = {
-    target: UserReportTarget;
-    /**
-     * Reason for the report
-     */
-    reason: 'WRONG_TRANSLATION' | 'WRONG_TIMING' | 'WRONG_AUDIO' | 'NSFW_NOT_TAGGED' | 'DUPLICATE_SEGMENT' | 'WRONG_METADATA' | 'MISSING_EPISODES' | 'WRONG_COVER_IMAGE' | 'INAPPROPRIATE_CONTENT' | 'OTHER';
-    /**
-     * Optional description with additional details
-     */
-    description?: string;
+    updatedAt: string;
 };
 export type UserPreferences = {
-    /**
-     * Lab feature opt-in flags keyed by feature key
-     */
-    labs?: {
-        [key: string]: boolean;
-    };
     /**
      * Preferred language for media names display
      */
@@ -1587,11 +1588,11 @@ export type ActivityType = 'SEARCH' | 'ANKI_EXPORT' | 'SEGMENT_PLAY' | 'LIST_ADD
 export type UserActivity = {
     id: number;
     activityType: ActivityType;
-    segmentUuid?: string;
-    mediaId?: number;
-    searchQuery?: string;
-    animeName?: string;
-    japaneseText?: string;
+    segmentUuid: string;
+    mediaId: number;
+    searchQuery: string;
+    mediaName: string;
+    japaneseText: string;
     createdAt: string;
 };
 /**
@@ -1606,10 +1607,6 @@ export type Collection = {
      * Name of the collection
      */
     name: string;
-    /**
-     * User ID who owns the collection
-     */
-    userId: number;
     /**
      * Visibility of the collection
      */
@@ -1617,15 +1614,15 @@ export type Collection = {
     /**
      * Number of segments in the collection
      */
-    segmentCount?: number;
+    segmentCount: number;
     /**
      * When the collection was created
      */
-    createdAt?: string;
+    createdAt: string;
     /**
      * When the collection was last updated
      */
-    updatedAt?: string;
+    updatedAt: string;
 };
 export type UserExportCollection = Collection & {
     /**
@@ -1650,32 +1647,32 @@ export type UserExportResponse = {
 };
 export type UserLabFeature = {
     /**
-     * Unique identifier for the lab feature
+     * Unique identifier for the feature
      */
     key: string;
     /**
-     * Human-readable feature name
+     * Human-readable feature name (only present for labs)
      */
-    name: string;
+    name?: string;
     /**
-     * Description of what the feature does
+     * Description of what the feature does (only present for labs)
      */
-    description: string;
+    description?: string;
     /**
-     * Whether the feature is globally available
+     * Whether this feature is currently active for the user
      */
-    enabled: boolean;
+    active: boolean;
     /**
-     * Whether the user has opted in to this feature
+     * Whether the user can toggle this feature (lab=true, flag=false)
      */
-    userEnabled: boolean;
+    userControllable: boolean;
 };
 /**
  * Paginated collection list response
  */
 export type CollectionListResponse = {
     collections: Array<Collection>;
-    pagination: CursorPagination;
+    pagination: OpaqueCursorPagination;
 };
 /**
  * Request body for creating a new collection
@@ -1702,14 +1699,22 @@ export type CollectionWithSegments = {
      * Name of the collection
      */
     name: string;
-    /**
-     * User ID who owns the collection
-     */
-    userId: number;
     /**
      * Visibility of the collection
      */
     visibility: 'PUBLIC' | 'PRIVATE';
+    /**
+     * Number of segments in the collection
+     */
+    segmentCount: number;
+    /**
+     * When the collection was created
+     */
+    createdAt: string;
+    /**
+     * When the collection was last updated
+     */
+    updatedAt: string;
     /**
      * Saved segments with their search result data
      */
@@ -1717,18 +1722,18 @@ export type CollectionWithSegments = {
         /**
          * Position in the collection
          */
-        position?: number;
+        position: number;
         /**
          * User annotation
          */
-        note?: string;
-        result?: Segment;
+        note: string;
+        result: Segment;
     }>;
-    includes?: {
+    includes: {
         /**
          * Media objects keyed by mediaId
          */
-        media?: {
+        media: {
             [key: string]: Media;
         };
     };
@@ -1736,7 +1741,7 @@ export type CollectionWithSegments = {
      * Total number of segments in the collection
      */
     totalCount: number;
-    pagination: CursorPagination;
+    pagination: OpaqueCursorPagination;
 };
 /**
  * Request to reindex segments from the database into Elasticsearch
@@ -1766,44 +1771,44 @@ export type ReindexResponse = {
     /**
      * Whether the reindex operation completed successfully
      */
-    success?: boolean;
+    success: boolean;
     /**
      * Human-readable message about the reindex operation
      */
-    message?: string;
+    message: string;
     /**
      * Statistics about the reindex operation
      */
-    stats?: {
+    stats: {
         /**
          * Total number of segments processed
          */
-        totalSegments?: number;
+        totalSegments: number;
         /**
          * Number of segments successfully indexed
          */
-        successfulIndexes?: number;
+        successfulIndexes: number;
         /**
          * Number of segments that failed to index
          */
-        failedIndexes?: number;
+        failedIndexes: number;
         /**
          * Number of media items processed
          */
-        mediaProcessed?: number;
+        mediaProcessed: number;
     };
     /**
      * Array of errors that occurred during reindexing (if any)
      */
-    errors?: Array<{
+    errors: Array<{
         /**
          * ID of the segment that failed
          */
-        segmentId?: number;
+        segmentId: number;
         /**
          * Error message
          */
-        error?: string;
+        error: string;
     }>;
 };
 export type AdminReport = Report & {
@@ -1818,7 +1823,7 @@ export type AdminReport = Report & {
 };
 export type AdminReportListResponse = {
     reports: Array<AdminReport>;
-    pagination: CursorPagination;
+    pagination: OpaqueCursorPagination;
 };
 export type UpdateReportRequest = {
     /**
@@ -1830,41 +1835,13 @@ export type UpdateReportRequest = {
      */
     adminNotes?: string;
 };
-export type RunReviewResponse = {
-    /**
-     * Category filter used
-     */
-    category: string;
-    checksRun: Array<{
-        /**
-         * Check identifier
-         */
-        checkName: string;
-        /**
-         * Human-readable check name
-         */
-        label: string;
-        /**
-         * Number of reports created
-         */
-        resultCount: number;
-        /**
-         * ID of the created run record
-         */
-        runId: number;
-    }>;
-    /**
-     * Total reports created across all checks
-     */
-    totalReports: number;
-};
-export type ReviewCheck = {
+export type MediaAudit = {
     /**
-     * Check ID
+     * Audit ID
      */
     id: number;
     /**
-     * Unique check identifier
+     * Unique audit identifier
      */
     name: string;
     /**
@@ -1872,11 +1849,11 @@ export type ReviewCheck = {
      */
     label: string;
     /**
-     * What this check does
+     * What this audit does
      */
     description: string;
     /**
-     * What level this check operates on
+     * What level this audit operates on
      */
     targetType: 'MEDIA' | 'EPISODE';
     /**
@@ -1886,40 +1863,68 @@ export type ReviewCheck = {
         [key: string]: unknown;
     };
     /**
-     * Whether this check is active
+     * Whether this audit is active
      */
     enabled: boolean;
     /**
      * Schema for threshold fields (from registry)
      */
-    thresholdSchema?: Array<{
-        key?: string;
-        label?: string;
-        type?: 'number' | 'boolean';
-        default?: number | boolean;
+    thresholdSchema: Array<{
+        key: string;
+        label: string;
+        type: 'number' | 'boolean';
+        default: number | boolean;
         min?: number;
         max?: number;
     }>;
     /**
-     * Latest run info for this check
+     * Latest run info for this audit
      */
-    latestRun?: {
-        id?: number;
-        resultCount?: number;
-        createdAt?: string;
+    latestRun: {
+        id: number;
+        resultCount: number;
+        createdAt: string;
     };
-    createdAt?: string;
-    updatedAt?: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export type RunAuditResponse = {
+    /**
+     * Category filter used
+     */
+    category: string;
+    checksRun: Array<{
+        /**
+         * Audit identifier
+         */
+        auditName: string;
+        /**
+         * Human-readable audit name
+         */
+        label: string;
+        /**
+         * Number of reports created
+         */
+        resultCount: number;
+        /**
+         * ID of the created run record
+         */
+        runId: number;
+    }>;
+    /**
+     * Total reports created across all audits
+     */
+    totalReports: number;
 };
-export type ReviewCheckRun = {
+export type MediaAuditRun = {
     /**
      * Run ID
      */
     id: number;
     /**
-     * Name of the check that was run
+     * Name of the audit that was run
      */
-    checkName: string;
+    auditName: string;
     /**
      * Category filter used (ANIME/JDRAMA) or null for all
      */
@@ -1939,32 +1944,6 @@ export type ReviewCheckRun = {
      */
     createdAt: string;
 };
-export type ReviewAllowlist = {
-    /**
-     * Allowlist entry ID
-     */
-    id: number;
-    /**
-     * Name of the check this entry applies to
-     */
-    checkName: string;
-    /**
-     * Media ID to exclude
-     */
-    mediaId: number;
-    /**
-     * Episode number to exclude (null for media-level checks)
-     */
-    episodeNumber?: number;
-    /**
-     * Why this was allowlisted
-     */
-    reason?: string;
-    /**
-     * When this entry was created
-     */
-    createdAt: string;
-};
 export type SearchData = {
     body?: SearchRequest;
     path?: never;
@@ -1977,7 +1956,7 @@ export type SearchErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2013,7 +1992,7 @@ export type GetSearchStatsErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2049,7 +2028,7 @@ export type SearchWordsErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2080,11 +2059,11 @@ export type ListMediaData = {
         /**
          * Number of results per page
          */
-        limit?: number;
+        take?: number;
         /**
-         * Pagination cursor offset
+         * Opaque pagination cursor token
          */
-        cursor?: number;
+        cursor?: string;
         /**
          * Filter by media category
          */
@@ -2094,7 +2073,7 @@ export type ListMediaData = {
          */
         query?: string;
         /**
-         * Resources to expand in the media response (`media.characters` implies `media`)
+         * Resources to expand in the media response
          */
         include?: Array<MediaIncludeExpansion>;
     };
@@ -2106,7 +2085,7 @@ export type ListMediaErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2134,15 +2113,109 @@ export type CreateMediaData = {
     body: MediaCreateRequest;
     path?: never;
     query?: never;
-    url: '/v1/media';
+    url: '/v1/media';
+};
+export type CreateMediaErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized (API key)
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Conflict
+     */
+    409: Error409;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type CreateMediaError = CreateMediaErrors[keyof CreateMediaErrors];
+export type CreateMediaResponses = {
+    /**
+     * Created
+     */
+    201: Media;
+};
+export type CreateMediaResponse = CreateMediaResponses[keyof CreateMediaResponses];
+export type AutocompleteMediaData = {
+    body?: never;
+    path?: never;
+    query: {
+        /**
+         * Search term to match against media names (English, Japanese, romaji)
+         */
+        query: string;
+        /**
+         * Maximum number of results to return
+         */
+        take?: number;
+        /**
+         * Filter by media category
+         */
+        category?: 'ANIME' | 'JDRAMA';
+    };
+    url: '/v1/media/autocomplete';
+};
+export type AutocompleteMediaErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized (API key)
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AutocompleteMediaError = AutocompleteMediaErrors[keyof AutocompleteMediaErrors];
+export type AutocompleteMediaResponses = {
+    /**
+     * OK
+     */
+    200: MediaAutocompleteResponse;
+};
+export type AutocompleteMediaResponse = AutocompleteMediaResponses[keyof AutocompleteMediaResponses];
+export type GetSegmentByUuidData = {
+    body?: never;
+    path: {
+        /**
+         * Segment UUID
+         */
+        uuid: string;
+    };
+    query?: never;
+    url: '/v1/media/segments/{uuid}';
 };
-export type CreateMediaErrors = {
+export type GetSegmentByUuidErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2150,9 +2223,9 @@ export type CreateMediaErrors = {
      */
     403: Error403;
     /**
-     * Conflict
+     * Not Found
      */
-    409: Error409;
+    404: Error404;
     /**
      * Too Many Requests
      */
@@ -2162,32 +2235,32 @@ export type CreateMediaErrors = {
      */
     500: Error500;
 };
-export type CreateMediaError = CreateMediaErrors[keyof CreateMediaErrors];
-export type CreateMediaResponses = {
+export type GetSegmentByUuidError = GetSegmentByUuidErrors[keyof GetSegmentByUuidErrors];
+export type GetSegmentByUuidResponses = {
     /**
-     * Created
+     * OK
      */
-    201: Media;
+    200: Segment;
 };
-export type CreateMediaResponse = CreateMediaResponses[keyof CreateMediaResponses];
-export type DeleteMediaData = {
-    body?: never;
+export type GetSegmentByUuidResponse = GetSegmentByUuidResponses[keyof GetSegmentByUuidResponses];
+export type UpdateSegmentByUuidData = {
+    body: SegmentUpdateRequest;
     path: {
         /**
-         * Media ID
+         * Segment UUID
          */
-        id: number;
+        uuid: string;
     };
     query?: never;
-    url: '/v1/media/{id}';
+    url: '/v1/media/segments/{uuid}';
 };
-export type DeleteMediaErrors = {
+export type UpdateSegmentByUuidErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key or session)
      */
     401: Error401;
     /**
@@ -2207,37 +2280,41 @@ export type DeleteMediaErrors = {
      */
     500: Error500;
 };
-export type DeleteMediaError = DeleteMediaErrors[keyof DeleteMediaErrors];
-export type DeleteMediaResponses = {
+export type UpdateSegmentByUuidError = UpdateSegmentByUuidErrors[keyof UpdateSegmentByUuidErrors];
+export type UpdateSegmentByUuidResponses = {
     /**
-     * No Content
+     * Single segment response with internal fields
      */
-    204: void;
+    200: SegmentInternal;
 };
-export type DeleteMediaResponse = DeleteMediaResponses[keyof DeleteMediaResponses];
-export type GetMediaData = {
+export type UpdateSegmentByUuidResponse = UpdateSegmentByUuidResponses[keyof UpdateSegmentByUuidResponses];
+export type GetSegmentContextData = {
     body?: never;
     path: {
         /**
-         * Media ID
+         * Segment UUID
          */
-        id: number;
+        uuid: string;
     };
     query?: {
         /**
-         * Resources to expand in the media response (`media.characters` implies `media`)
+         * Number of segments to return before and after the target
          */
-        include?: Array<MediaIncludeExpansion>;
+        take?: number;
+        /**
+         * Content ratings to include (omit for all ratings)
+         */
+        contentRating?: Array<ContentRating>;
     };
-    url: '/v1/media/{id}';
+    url: '/v1/media/segments/{uuid}/context';
 };
-export type GetMediaErrors = {
+export type GetSegmentContextErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2257,42 +2334,46 @@ export type GetMediaErrors = {
      */
     500: Error500;
 };
-export type GetMediaError = GetMediaErrors[keyof GetMediaErrors];
-export type GetMediaResponses = {
+export type GetSegmentContextError = GetSegmentContextErrors[keyof GetSegmentContextErrors];
+export type GetSegmentContextResponses = {
     /**
      * OK
      */
-    200: Media;
+    200: SegmentContextResponse;
 };
-export type GetMediaResponse = GetMediaResponses[keyof GetMediaResponses];
-export type UpdateMediaData = {
-    body: MediaUpdateRequest;
-    path: {
+export type GetSegmentContextResponse = GetSegmentContextResponses[keyof GetSegmentContextResponses];
+export type ListSeriesData = {
+    body?: never;
+    path?: never;
+    query?: {
         /**
-         * Media ID
+         * Number of results per page
          */
-        id: number;
+        take?: number;
+        /**
+         * Opaque pagination cursor token
+         */
+        cursor?: string;
+        /**
+         * Case-insensitive search across English, Japanese, and Romaji names
+         */
+        query?: string;
     };
-    query?: never;
-    url: '/v1/media/{id}';
+    url: '/v1/media/series';
 };
-export type UpdateMediaErrors = {
+export type ListSeriesErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
      * Forbidden
      */
     403: Error403;
-    /**
-     * Not Found
-     */
-    404: Error404;
     /**
      * Too Many Requests
      */
@@ -2302,51 +2383,46 @@ export type UpdateMediaErrors = {
      */
     500: Error500;
 };
-export type UpdateMediaError = UpdateMediaErrors[keyof UpdateMediaErrors];
-export type UpdateMediaResponses = {
+export type ListSeriesError = ListSeriesErrors[keyof ListSeriesErrors];
+export type ListSeriesResponses = {
     /**
      * OK
      */
-    200: Media;
+    200: SeriesListResponse;
 };
-export type UpdateMediaResponse = UpdateMediaResponses[keyof UpdateMediaResponses];
-export type ListEpisodesData = {
-    body?: never;
-    path: {
+export type ListSeriesResponse = ListSeriesResponses[keyof ListSeriesResponses];
+export type CreateSeriesData = {
+    body: {
         /**
-         * ID of the media
+         * Japanese name of the series
          */
-        mediaId: number;
-    };
-    query?: {
+        nameJa: string;
         /**
-         * Maximum number of episodes to return
+         * Romaji name of the series
          */
-        limit?: number;
+        nameRomaji: string;
         /**
-         * Episode number to start from (for pagination)
+         * English name of the series
          */
-        cursor?: number;
+        nameEn: string;
     };
-    url: '/v1/media/{mediaId}/episodes';
+    path?: never;
+    query?: never;
+    url: '/v1/media/series';
 };
-export type ListEpisodesErrors = {
+export type CreateSeriesErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
      * Forbidden
      */
     403: Error403;
-    /**
-     * Not Found
-     */
-    404: Error404;
     /**
      * Too Many Requests
      */
@@ -2356,32 +2432,32 @@ export type ListEpisodesErrors = {
      */
     500: Error500;
 };
-export type ListEpisodesError = ListEpisodesErrors[keyof ListEpisodesErrors];
-export type ListEpisodesResponses = {
+export type CreateSeriesError = CreateSeriesErrors[keyof CreateSeriesErrors];
+export type CreateSeriesResponses = {
     /**
-     * Paginated list of episodes
+     * Created
      */
-    200: EpisodeListResponse;
+    201: Series;
 };
-export type ListEpisodesResponse = ListEpisodesResponses[keyof ListEpisodesResponses];
-export type CreateEpisodeData = {
-    body: EpisodeCreateRequest;
+export type CreateSeriesResponse = CreateSeriesResponses[keyof CreateSeriesResponses];
+export type DeleteSeriesData = {
+    body?: never;
     path: {
         /**
-         * ID of the media
+         * Series ID
          */
-        mediaId: number;
+        id: number;
     };
     query?: never;
-    url: '/v1/media/{mediaId}/episodes';
+    url: '/v1/media/series/{id}';
 };
-export type CreateEpisodeErrors = {
+export type DeleteSeriesErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2392,10 +2468,6 @@ export type CreateEpisodeErrors = {
      * Not Found
      */
     404: Error404;
-    /**
-     * Conflict
-     */
-    409: Error409;
     /**
      * Too Many Requests
      */
@@ -2405,36 +2477,37 @@ export type CreateEpisodeErrors = {
      */
     500: Error500;
 };
-export type CreateEpisodeError = CreateEpisodeErrors[keyof CreateEpisodeErrors];
-export type CreateEpisodeResponses = {
+export type DeleteSeriesError = DeleteSeriesErrors[keyof DeleteSeriesErrors];
+export type DeleteSeriesResponses = {
     /**
-     * Single episode response
+     * No Content
      */
-    201: Episode;
+    204: void;
 };
-export type CreateEpisodeResponse = CreateEpisodeResponses[keyof CreateEpisodeResponses];
-export type DeleteEpisodeData = {
+export type DeleteSeriesResponse = DeleteSeriesResponses[keyof DeleteSeriesResponses];
+export type GetSeriesData = {
     body?: never;
     path: {
         /**
-         * ID of the media
+         * Series ID
          */
-        mediaId: number;
+        id: number;
+    };
+    query?: {
         /**
-         * Episode number
+         * Resources to expand in the series response
          */
-        episodeNumber: number;
+        include?: Array<MediaIncludeExpansion>;
     };
-    query?: never;
-    url: '/v1/media/{mediaId}/episodes/{episodeNumber}';
+    url: '/v1/media/series/{id}';
 };
-export type DeleteEpisodeErrors = {
+export type GetSeriesErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2454,36 +2527,45 @@ export type DeleteEpisodeErrors = {
      */
     500: Error500;
 };
-export type DeleteEpisodeError = DeleteEpisodeErrors[keyof DeleteEpisodeErrors];
-export type DeleteEpisodeResponses = {
+export type GetSeriesError = GetSeriesErrors[keyof GetSeriesErrors];
+export type GetSeriesResponses = {
     /**
-     * Episode successfully deleted
+     * OK
      */
-    204: void;
+    200: SeriesWithMedia;
 };
-export type DeleteEpisodeResponse = DeleteEpisodeResponses[keyof DeleteEpisodeResponses];
-export type GetEpisodeData = {
-    body?: never;
-    path: {
+export type GetSeriesResponse = GetSeriesResponses[keyof GetSeriesResponses];
+export type UpdateSeriesData = {
+    body: {
         /**
-         * ID of the media
+         * Updated Japanese name
          */
-        mediaId: number;
+        nameJa?: string;
         /**
-         * Episode number
+         * Updated Romaji name
          */
-        episodeNumber: number;
+        nameRomaji?: string;
+        /**
+         * Updated English name
+         */
+        nameEn?: string;
+    };
+    path: {
+        /**
+         * Series ID
+         */
+        id: number;
     };
     query?: never;
-    url: '/v1/media/{mediaId}/episodes/{episodeNumber}';
+    url: '/v1/media/series/{id}';
 };
-export type GetEpisodeErrors = {
+export type UpdateSeriesErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2503,36 +2585,41 @@ export type GetEpisodeErrors = {
      */
     500: Error500;
 };
-export type GetEpisodeError = GetEpisodeErrors[keyof GetEpisodeErrors];
-export type GetEpisodeResponses = {
+export type UpdateSeriesError = UpdateSeriesErrors[keyof UpdateSeriesErrors];
+export type UpdateSeriesResponses = {
     /**
-     * Single episode response
+     * OK
      */
-    200: Episode;
+    200: Series;
 };
-export type GetEpisodeResponse = GetEpisodeResponses[keyof GetEpisodeResponses];
-export type UpdateEpisodeData = {
-    body: EpisodeUpdateRequest;
-    path: {
+export type UpdateSeriesResponse = UpdateSeriesResponses[keyof UpdateSeriesResponses];
+export type AddMediaToSeriesData = {
+    body: {
         /**
-         * ID of the media
+         * Media ID to add
          */
         mediaId: number;
         /**
-         * Episode number
+         * Position in the series (1-indexed)
          */
-        episodeNumber: number;
+        position: number;
+    };
+    path: {
+        /**
+         * Series ID
+         */
+        id: number;
     };
     query?: never;
-    url: '/v1/media/{mediaId}/episodes/{episodeNumber}';
+    url: '/v1/media/series/{id}/media';
 };
-export type UpdateEpisodeErrors = {
+export type AddMediaToSeriesErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2552,45 +2639,36 @@ export type UpdateEpisodeErrors = {
      */
     500: Error500;
 };
-export type UpdateEpisodeError = UpdateEpisodeErrors[keyof UpdateEpisodeErrors];
-export type UpdateEpisodeResponses = {
+export type AddMediaToSeriesError = AddMediaToSeriesErrors[keyof AddMediaToSeriesErrors];
+export type AddMediaToSeriesResponses = {
     /**
-     * Single episode response
+     * No Content
      */
-    200: Episode;
+    204: void;
 };
-export type UpdateEpisodeResponse = UpdateEpisodeResponses[keyof UpdateEpisodeResponses];
-export type ListSegmentsData = {
+export type AddMediaToSeriesResponse = AddMediaToSeriesResponses[keyof AddMediaToSeriesResponses];
+export type RemoveMediaFromSeriesData = {
     body?: never;
     path: {
         /**
-         * ID of the media
-         */
-        mediaId: number;
-        /**
-         * Episode number
-         */
-        episodeNumber: number;
-    };
-    query?: {
-        /**
-         * Maximum number of segments to return
+         * Series ID
          */
-        limit?: number;
+        id: number;
         /**
-         * Segment ID to start from (for pagination)
+         * Media ID
          */
-        cursor?: number;
+        mediaId: number;
     };
-    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments';
+    query?: never;
+    url: '/v1/media/series/{id}/media/{mediaId}';
 };
-export type ListSegmentsErrors = {
+export type RemoveMediaFromSeriesErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2610,42 +2688,41 @@ export type ListSegmentsErrors = {
      */
     500: Error500;
 };
-export type ListSegmentsError = ListSegmentsErrors[keyof ListSegmentsErrors];
-export type ListSegmentsResponses = {
+export type RemoveMediaFromSeriesError = RemoveMediaFromSeriesErrors[keyof RemoveMediaFromSeriesErrors];
+export type RemoveMediaFromSeriesResponses = {
     /**
-     * Paginated segment list response
+     * No Content
      */
-    200: {
+    204: void;
+};
+export type RemoveMediaFromSeriesResponse = RemoveMediaFromSeriesResponses[keyof RemoveMediaFromSeriesResponses];
+export type UpdateSeriesMediaData = {
+    body: {
         /**
-         * Array of segment objects
+         * New position in the series (1-indexed)
          */
-        segments: Array<Segment>;
-        pagination: CursorPagination;
+        position: number;
     };
-};
-export type ListSegmentsResponse = ListSegmentsResponses[keyof ListSegmentsResponses];
-export type CreateSegmentData = {
-    body: SegmentCreateRequest;
     path: {
         /**
-         * ID of the media
+         * Series ID
          */
-        mediaId: number;
+        id: number;
         /**
-         * Episode number
+         * Media ID
          */
-        episodeNumber: number;
+        mediaId: number;
     };
     query?: never;
-    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments';
+    url: '/v1/media/series/{id}/media/{mediaId}';
 };
-export type CreateSegmentErrors = {
+export type UpdateSeriesMediaErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2656,10 +2733,6 @@ export type CreateSegmentErrors = {
      * Not Found
      */
     404: Error404;
-    /**
-     * Conflict
-     */
-    409: Error409;
     /**
      * Too Many Requests
      */
@@ -2669,40 +2742,32 @@ export type CreateSegmentErrors = {
      */
     500: Error500;
 };
-export type CreateSegmentError = CreateSegmentErrors[keyof CreateSegmentErrors];
-export type CreateSegmentResponses = {
+export type UpdateSeriesMediaError = UpdateSeriesMediaErrors[keyof UpdateSeriesMediaErrors];
+export type UpdateSeriesMediaResponses = {
     /**
-     * Single segment response with internal fields
+     * No Content
      */
-    201: SegmentInternal;
+    204: void;
 };
-export type CreateSegmentResponse = CreateSegmentResponses[keyof CreateSegmentResponses];
-export type DeleteSegmentData = {
+export type UpdateSeriesMediaResponse = UpdateSeriesMediaResponses[keyof UpdateSeriesMediaResponses];
+export type GetCharacterData = {
     body?: never;
     path: {
         /**
-         * ID of the media
-         */
-        mediaId: number;
-        /**
-         * Episode number
-         */
-        episodeNumber: number;
-        /**
-         * Segment ID
+         * Internal character ID
          */
         id: number;
     };
     query?: never;
-    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments/{id}';
+    url: '/v1/media/characters/{id}';
 };
-export type DeleteSegmentErrors = {
+export type GetCharacterErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2722,40 +2787,32 @@ export type DeleteSegmentErrors = {
      */
     500: Error500;
 };
-export type DeleteSegmentError = DeleteSegmentErrors[keyof DeleteSegmentErrors];
-export type DeleteSegmentResponses = {
+export type GetCharacterError = GetCharacterErrors[keyof GetCharacterErrors];
+export type GetCharacterResponses = {
     /**
-     * Segment successfully deleted
+     * OK
      */
-    204: void;
+    200: CharacterWithMedia;
 };
-export type DeleteSegmentResponse = DeleteSegmentResponses[keyof DeleteSegmentResponses];
-export type GetSegmentData = {
+export type GetCharacterResponse = GetCharacterResponses[keyof GetCharacterResponses];
+export type GetSeiyuuData = {
     body?: never;
     path: {
         /**
-         * ID of the media
-         */
-        mediaId: number;
-        /**
-         * Episode number
-         */
-        episodeNumber: number;
-        /**
-         * Segment ID
+         * Internal seiyuu ID
          */
         id: number;
     };
     query?: never;
-    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments/{id}';
+    url: '/v1/media/seiyuu/{id}';
 };
-export type GetSegmentErrors = {
+export type GetSeiyuuErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2775,40 +2832,32 @@ export type GetSegmentErrors = {
      */
     500: Error500;
 };
-export type GetSegmentError = GetSegmentErrors[keyof GetSegmentErrors];
-export type GetSegmentResponses = {
+export type GetSeiyuuError = GetSeiyuuErrors[keyof GetSeiyuuErrors];
+export type GetSeiyuuResponses = {
     /**
-     * Single segment response
+     * OK
      */
-    200: Segment;
+    200: SeiyuuWithRoles;
 };
-export type GetSegmentResponse = GetSegmentResponses[keyof GetSegmentResponses];
-export type UpdateSegmentData = {
-    body: SegmentUpdateRequest;
+export type GetSeiyuuResponse = GetSeiyuuResponses[keyof GetSeiyuuResponses];
+export type DeleteMediaData = {
+    body?: never;
     path: {
         /**
-         * ID of the media
-         */
-        mediaId: number;
-        /**
-         * Episode number
-         */
-        episodeNumber: number;
-        /**
-         * Segment ID
+         * Media ID
          */
         id: number;
     };
     query?: never;
-    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments/{id}';
+    url: '/v1/media/{id}';
 };
-export type UpdateSegmentErrors = {
+export type DeleteMediaErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2828,32 +2877,37 @@ export type UpdateSegmentErrors = {
      */
     500: Error500;
 };
-export type UpdateSegmentError = UpdateSegmentErrors[keyof UpdateSegmentErrors];
-export type UpdateSegmentResponses = {
+export type DeleteMediaError = DeleteMediaErrors[keyof DeleteMediaErrors];
+export type DeleteMediaResponses = {
     /**
-     * Single segment response with internal fields
+     * No Content
      */
-    200: SegmentInternal;
+    204: void;
 };
-export type UpdateSegmentResponse = UpdateSegmentResponses[keyof UpdateSegmentResponses];
-export type GetSegmentByUuidData = {
+export type DeleteMediaResponse = DeleteMediaResponses[keyof DeleteMediaResponses];
+export type GetMediaData = {
     body?: never;
     path: {
         /**
-         * Segment UUID
+         * Media ID
          */
-        uuid: string;
+        id: number;
     };
-    query?: never;
-    url: '/v1/media/segments/{uuid}';
+    query?: {
+        /**
+         * Resources to expand in the media response
+         */
+        include?: Array<MediaIncludeExpansion>;
+    };
+    url: '/v1/media/{id}';
 };
-export type GetSegmentByUuidErrors = {
+export type GetMediaErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2873,42 +2927,32 @@ export type GetSegmentByUuidErrors = {
      */
     500: Error500;
 };
-export type GetSegmentByUuidError = GetSegmentByUuidErrors[keyof GetSegmentByUuidErrors];
-export type GetSegmentByUuidResponses = {
-    200: Segment;
+export type GetMediaError = GetMediaErrors[keyof GetMediaErrors];
+export type GetMediaResponses = {
+    /**
+     * OK
+     */
+    200: Media;
 };
-export type GetSegmentByUuidResponse = GetSegmentByUuidResponses[keyof GetSegmentByUuidResponses];
-export type GetSegmentContextData = {
-    body?: never;
+export type GetMediaResponse = GetMediaResponses[keyof GetMediaResponses];
+export type UpdateMediaData = {
+    body: MediaUpdateRequest;
     path: {
         /**
-         * Segment UUID
-         */
-        uuid: string;
-    };
-    query?: {
-        /**
-         * Number of segments to return before and after the target
-         */
-        limit?: number;
-        /**
-         * Content ratings to include (omit for all ratings)
-         */
-        contentRating?: Array<ContentRating>;
-        /**
-         * Resources to expand in the response includes block
+         * Media ID
          */
-        include?: Array<IncludeExpansion>;
+        id: number;
     };
-    url: '/v1/media/segments/{uuid}/context';
+    query?: never;
+    url: '/v1/media/{id}';
 };
-export type GetSegmentContextErrors = {
+export type UpdateMediaErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2928,46 +2972,51 @@ export type GetSegmentContextErrors = {
      */
     500: Error500;
 };
-export type GetSegmentContextError = GetSegmentContextErrors[keyof GetSegmentContextErrors];
-export type GetSegmentContextResponses = {
+export type UpdateMediaError = UpdateMediaErrors[keyof UpdateMediaErrors];
+export type UpdateMediaResponses = {
     /**
      * OK
      */
-    200: SegmentContextResponse;
+    200: Media;
 };
-export type GetSegmentContextResponse = GetSegmentContextResponses[keyof GetSegmentContextResponses];
-export type ListSeriesData = {
+export type UpdateMediaResponse = UpdateMediaResponses[keyof UpdateMediaResponses];
+export type ListEpisodesData = {
     body?: never;
-    path?: never;
-    query?: {
+    path: {
         /**
-         * Number of results per page
+         * ID of the media
          */
-        limit?: number;
+        mediaId: number;
+    };
+    query?: {
         /**
-         * Pagination cursor offset
+         * Maximum number of episodes to return
          */
-        cursor?: number;
+        take?: number;
         /**
-         * Case-insensitive search across English, Japanese, and Romaji names
+         * Opaque pagination cursor token
          */
-        query?: string;
+        cursor?: string;
     };
-    url: '/v1/media/series';
+    url: '/v1/media/{mediaId}/episodes';
 };
-export type ListSeriesErrors = {
+export type ListEpisodesErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
      * Forbidden
      */
     403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
     /**
      * Too Many Requests
      */
@@ -2977,46 +3026,46 @@ export type ListSeriesErrors = {
      */
     500: Error500;
 };
-export type ListSeriesError = ListSeriesErrors[keyof ListSeriesErrors];
-export type ListSeriesResponses = {
+export type ListEpisodesError = ListEpisodesErrors[keyof ListEpisodesErrors];
+export type ListEpisodesResponses = {
     /**
-     * OK
+     * Paginated list of episodes
      */
-    200: SeriesListResponse;
+    200: EpisodeListResponse;
 };
-export type ListSeriesResponse = ListSeriesResponses[keyof ListSeriesResponses];
-export type CreateSeriesData = {
-    body: {
-        /**
-         * Japanese name of the series
-         */
-        nameJa: string;
-        /**
-         * Romaji name of the series
-         */
-        nameRomaji: string;
+export type ListEpisodesResponse = ListEpisodesResponses[keyof ListEpisodesResponses];
+export type CreateEpisodeData = {
+    body: EpisodeCreateRequest;
+    path: {
         /**
-         * English name of the series
+         * ID of the media
          */
-        nameEn: string;
+        mediaId: number;
     };
-    path?: never;
     query?: never;
-    url: '/v1/media/series';
+    url: '/v1/media/{mediaId}/episodes';
 };
-export type CreateSeriesErrors = {
+export type CreateEpisodeErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
      * Forbidden
      */
     403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Conflict
+     */
+    409: Error409;
     /**
      * Too Many Requests
      */
@@ -3026,32 +3075,36 @@ export type CreateSeriesErrors = {
      */
     500: Error500;
 };
-export type CreateSeriesError = CreateSeriesErrors[keyof CreateSeriesErrors];
-export type CreateSeriesResponses = {
+export type CreateEpisodeError = CreateEpisodeErrors[keyof CreateEpisodeErrors];
+export type CreateEpisodeResponses = {
     /**
-     * Created
+     * Single episode response
      */
-    201: Series;
+    201: Episode;
 };
-export type CreateSeriesResponse = CreateSeriesResponses[keyof CreateSeriesResponses];
-export type DeleteSeriesData = {
+export type CreateEpisodeResponse = CreateEpisodeResponses[keyof CreateEpisodeResponses];
+export type DeleteEpisodeData = {
     body?: never;
     path: {
         /**
-         * Series ID
+         * ID of the media
          */
-        id: number;
+        mediaId: number;
+        /**
+         * Episode number
+         */
+        episodeNumber: number;
     };
     query?: never;
-    url: '/v1/media/series/{id}';
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}';
 };
-export type DeleteSeriesErrors = {
+export type DeleteEpisodeErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -3071,37 +3124,36 @@ export type DeleteSeriesErrors = {
      */
     500: Error500;
 };
-export type DeleteSeriesError = DeleteSeriesErrors[keyof DeleteSeriesErrors];
-export type DeleteSeriesResponses = {
+export type DeleteEpisodeError = DeleteEpisodeErrors[keyof DeleteEpisodeErrors];
+export type DeleteEpisodeResponses = {
     /**
-     * No Content
+     * Episode successfully deleted
      */
     204: void;
 };
-export type DeleteSeriesResponse = DeleteSeriesResponses[keyof DeleteSeriesResponses];
-export type GetSeriesData = {
+export type DeleteEpisodeResponse = DeleteEpisodeResponses[keyof DeleteEpisodeResponses];
+export type GetEpisodeData = {
     body?: never;
     path: {
         /**
-         * Series ID
+         * ID of the media
          */
-        id: number;
-    };
-    query?: {
+        mediaId: number;
         /**
-         * Resources to expand in the series response (`media.characters` implies `media`)
+         * Episode number
          */
-        include?: Array<MediaIncludeExpansion>;
+        episodeNumber: number;
     };
-    url: '/v1/media/series/{id}';
+    query?: never;
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}';
 };
-export type GetSeriesErrors = {
+export type GetEpisodeErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -3121,45 +3173,36 @@ export type GetSeriesErrors = {
      */
     500: Error500;
 };
-export type GetSeriesError = GetSeriesErrors[keyof GetSeriesErrors];
-export type GetSeriesResponses = {
+export type GetEpisodeError = GetEpisodeErrors[keyof GetEpisodeErrors];
+export type GetEpisodeResponses = {
     /**
-     * OK
+     * Single episode response
      */
-    200: SeriesWithMedia;
+    200: Episode;
 };
-export type GetSeriesResponse = GetSeriesResponses[keyof GetSeriesResponses];
-export type UpdateSeriesData = {
-    body: {
-        /**
-         * Updated Japanese name
-         */
-        nameJa?: string;
-        /**
-         * Updated Romaji name
-         */
-        nameRomaji?: string;
+export type GetEpisodeResponse = GetEpisodeResponses[keyof GetEpisodeResponses];
+export type UpdateEpisodeData = {
+    body: EpisodeUpdateRequest;
+    path: {
         /**
-         * Updated English name
+         * ID of the media
          */
-        nameEn?: string;
-    };
-    path: {
+        mediaId: number;
         /**
-         * Series ID
+         * Episode number
          */
-        id: number;
+        episodeNumber: number;
     };
     query?: never;
-    url: '/v1/media/series/{id}';
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}';
 };
-export type UpdateSeriesErrors = {
+export type UpdateEpisodeErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -3179,41 +3222,45 @@ export type UpdateSeriesErrors = {
      */
     500: Error500;
 };
-export type UpdateSeriesError = UpdateSeriesErrors[keyof UpdateSeriesErrors];
-export type UpdateSeriesResponses = {
+export type UpdateEpisodeError = UpdateEpisodeErrors[keyof UpdateEpisodeErrors];
+export type UpdateEpisodeResponses = {
     /**
-     * OK
+     * Single episode response
      */
-    200: Series;
+    200: Episode;
 };
-export type UpdateSeriesResponse = UpdateSeriesResponses[keyof UpdateSeriesResponses];
-export type AddMediaToSeriesData = {
-    body: {
+export type UpdateEpisodeResponse = UpdateEpisodeResponses[keyof UpdateEpisodeResponses];
+export type ListSegmentsData = {
+    body?: never;
+    path: {
         /**
-         * Media ID to add
+         * ID of the media
          */
         mediaId: number;
         /**
-         * Position in the series (1-indexed)
+         * Episode number
          */
-        position: number;
+        episodeNumber: number;
     };
-    path: {
+    query?: {
         /**
-         * Series ID
+         * Maximum number of segments to return
          */
-        id: number;
+        take?: number;
+        /**
+         * Opaque pagination cursor token
+         */
+        cursor?: string;
     };
-    query?: never;
-    url: '/v1/media/series/{id}/media';
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments';
 };
-export type AddMediaToSeriesErrors = {
+export type ListSegmentsErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -3233,36 +3280,42 @@ export type AddMediaToSeriesErrors = {
      */
     500: Error500;
 };
-export type AddMediaToSeriesError = AddMediaToSeriesErrors[keyof AddMediaToSeriesErrors];
-export type AddMediaToSeriesResponses = {
+export type ListSegmentsError = ListSegmentsErrors[keyof ListSegmentsErrors];
+export type ListSegmentsResponses = {
     /**
-     * No Content
+     * Paginated segment list response
      */
-    204: void;
+    200: {
+        /**
+         * Array of segment objects
+         */
+        segments: Array<Segment>;
+        pagination: OpaqueCursorPagination;
+    };
 };
-export type AddMediaToSeriesResponse = AddMediaToSeriesResponses[keyof AddMediaToSeriesResponses];
-export type RemoveMediaFromSeriesData = {
-    body?: never;
+export type ListSegmentsResponse = ListSegmentsResponses[keyof ListSegmentsResponses];
+export type CreateSegmentData = {
+    body: SegmentCreateRequest;
     path: {
         /**
-         * Series ID
+         * ID of the media
          */
-        id: number;
+        mediaId: number;
         /**
-         * Media ID
+         * Episode number
          */
-        mediaId: number;
+        episodeNumber: number;
     };
     query?: never;
-    url: '/v1/media/series/{id}/media/{mediaId}';
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments';
 };
-export type RemoveMediaFromSeriesErrors = {
+export type CreateSegmentErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -3273,6 +3326,10 @@ export type RemoveMediaFromSeriesErrors = {
      * Not Found
      */
     404: Error404;
+    /**
+     * Conflict
+     */
+    409: Error409;
     /**
      * Too Many Requests
      */
@@ -3282,41 +3339,40 @@ export type RemoveMediaFromSeriesErrors = {
      */
     500: Error500;
 };
-export type RemoveMediaFromSeriesError = RemoveMediaFromSeriesErrors[keyof RemoveMediaFromSeriesErrors];
-export type RemoveMediaFromSeriesResponses = {
+export type CreateSegmentError = CreateSegmentErrors[keyof CreateSegmentErrors];
+export type CreateSegmentResponses = {
     /**
-     * No Content
+     * Single segment response with internal fields
      */
-    204: void;
+    201: SegmentInternal;
 };
-export type RemoveMediaFromSeriesResponse = RemoveMediaFromSeriesResponses[keyof RemoveMediaFromSeriesResponses];
-export type UpdateSeriesMediaData = {
-    body: {
+export type CreateSegmentResponse = CreateSegmentResponses[keyof CreateSegmentResponses];
+export type DeleteSegmentData = {
+    body?: never;
+    path: {
         /**
-         * New position in the series (1-indexed)
+         * ID of the media
          */
-        position: number;
-    };
-    path: {
+        mediaId: number;
         /**
-         * Series ID
+         * Episode number
          */
-        id: number;
+        episodeNumber: number;
         /**
-         * Media ID
+         * Segment ID
          */
-        mediaId: number;
+        id: number;
     };
     query?: never;
-    url: '/v1/media/series/{id}/media/{mediaId}';
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments/{id}';
 };
-export type UpdateSeriesMediaErrors = {
+export type DeleteSegmentErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -3336,32 +3392,40 @@ export type UpdateSeriesMediaErrors = {
      */
     500: Error500;
 };
-export type UpdateSeriesMediaError = UpdateSeriesMediaErrors[keyof UpdateSeriesMediaErrors];
-export type UpdateSeriesMediaResponses = {
+export type DeleteSegmentError = DeleteSegmentErrors[keyof DeleteSegmentErrors];
+export type DeleteSegmentResponses = {
     /**
-     * No Content
+     * Segment successfully deleted
      */
     204: void;
 };
-export type UpdateSeriesMediaResponse = UpdateSeriesMediaResponses[keyof UpdateSeriesMediaResponses];
-export type GetCharacterData = {
+export type DeleteSegmentResponse = DeleteSegmentResponses[keyof DeleteSegmentResponses];
+export type GetSegmentData = {
     body?: never;
     path: {
         /**
-         * AniList character ID
+         * ID of the media
+         */
+        mediaId: number;
+        /**
+         * Episode number
+         */
+        episodeNumber: number;
+        /**
+         * Segment ID
          */
         id: number;
     };
     query?: never;
-    url: '/v1/media/characters/{id}';
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments/{id}';
 };
-export type GetCharacterErrors = {
+export type GetSegmentErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -3381,37 +3445,40 @@ export type GetCharacterErrors = {
      */
     500: Error500;
 };
-export type GetCharacterError = GetCharacterErrors[keyof GetCharacterErrors];
-export type GetCharacterResponses = {
+export type GetSegmentError = GetSegmentErrors[keyof GetSegmentErrors];
+export type GetSegmentResponses = {
     /**
-     * OK
+     * Single segment response
      */
-    200: CharacterWithMedia;
+    200: Segment;
 };
-export type GetCharacterResponse = GetCharacterResponses[keyof GetCharacterResponses];
-export type GetSeiyuuData = {
-    body?: never;
+export type GetSegmentResponse = GetSegmentResponses[keyof GetSegmentResponses];
+export type UpdateSegmentData = {
+    body: SegmentUpdateRequest;
     path: {
         /**
-         * AniList staff ID
+         * ID of the media
          */
-        id: number;
-    };
-    query?: {
+        mediaId: number;
+        /**
+         * Episode number
+         */
+        episodeNumber: number;
         /**
-         * Resources to expand in the response (`character` is included by default)
+         * Segment ID
          */
-        include?: Array<'character'>;
+        id: number;
     };
-    url: '/v1/media/seiyuu/{id}';
+    query?: never;
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments/{id}';
 };
-export type GetSeiyuuErrors = {
+export type UpdateSegmentErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -3431,14 +3498,14 @@ export type GetSeiyuuErrors = {
      */
     500: Error500;
 };
-export type GetSeiyuuError = GetSeiyuuErrors[keyof GetSeiyuuErrors];
-export type GetSeiyuuResponses = {
+export type UpdateSegmentError = UpdateSegmentErrors[keyof UpdateSegmentErrors];
+export type UpdateSegmentResponses = {
     /**
-     * OK
+     * Single segment response with internal fields
      */
-    200: SeiyuuWithRoles;
+    200: SegmentInternal;
 };
-export type GetSeiyuuResponse = GetSeiyuuResponses[keyof GetSeiyuuResponses];
+export type UpdateSegmentResponse = UpdateSegmentResponses[keyof UpdateSegmentResponses];
 export type GetUserQuotaData = {
     body?: never;
     path?: never;
@@ -3447,9 +3514,13 @@ export type GetUserQuotaData = {
 };
 export type GetUserQuotaErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
     /**
      * Too Many Requests
      */
@@ -3467,43 +3538,6 @@ export type GetUserQuotaResponses = {
     200: UserQuotaResponse;
 };
 export type GetUserQuotaResponse = GetUserQuotaResponses[keyof GetUserQuotaResponses];
-export type ListUserReportsData = {
-    body?: never;
-    path?: never;
-    query?: {
-        /**
-         * Cursor for pagination (report ID to start after)
-         */
-        cursor?: number;
-        /**
-         * Number of results per page
-         */
-        limit?: number;
-        /**
-         * Filter by report status
-         */
-        status?: 'PENDING' | 'CONCERN' | 'ACCEPTED' | 'REJECTED' | 'RESOLVED' | 'IGNORED';
-    };
-    url: '/v1/user/reports';
-};
-export type ListUserReportsErrors = {
-    /**
-     * Unauthorized
-     */
-    401: Error401;
-    /**
-     * Internal Server Error
-     */
-    500: Error500;
-};
-export type ListUserReportsError = ListUserReportsErrors[keyof ListUserReportsErrors];
-export type ListUserReportsResponses = {
-    /**
-     * OK
-     */
-    200: ReportListResponse;
-};
-export type ListUserReportsResponse = ListUserReportsResponses[keyof ListUserReportsResponses];
 export type CreateUserReportData = {
     body: CreateReportRequest;
     path?: never;
@@ -3516,7 +3550,7 @@ export type CreateUserReportErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -3544,7 +3578,7 @@ export type GetUserPreferencesData = {
 };
 export type GetUserPreferencesErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -3568,7 +3602,7 @@ export type UpdateUserPreferencesData = {
 };
 export type UpdateUserPreferencesErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -3597,7 +3631,7 @@ export type DeleteUserActivityData = {
 };
 export type DeleteUserActivityErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -3611,7 +3645,6 @@ export type DeleteUserActivityResponses = {
      * OK
      */
     200: {
-        message: string;
         deletedCount: number;
     };
 };
@@ -3621,13 +3654,13 @@ export type ListUserActivityData = {
     path?: never;
     query?: {
         /**
-         * Cursor for pagination (activity ID to start after)
+         * Opaque cursor token for keyset pagination
          */
-        cursor?: number;
+        cursor?: string;
         /**
          * Number of results per page
          */
-        limit?: number;
+        take?: number;
         /**
          * Filter by activity type
          */
@@ -3641,7 +3674,7 @@ export type ListUserActivityData = {
 };
 export type ListUserActivityErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -3656,10 +3689,44 @@ export type ListUserActivityResponses = {
      */
     200: {
         activities: Array<UserActivity>;
-        pagination: CursorPagination;
+        pagination: OpaqueCursorPagination;
     };
 };
 export type ListUserActivityResponse = ListUserActivityResponses[keyof ListUserActivityResponses];
+export type TrackUserActivityData = {
+    body: {
+        activityType: 'SEGMENT_PLAY';
+        segmentUuid?: string;
+        mediaId?: number;
+        mediaName?: string;
+        japaneseText?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/v1/user/activity';
+};
+export type TrackUserActivityErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized (session)
+     */
+    401: Error401;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type TrackUserActivityError = TrackUserActivityErrors[keyof TrackUserActivityErrors];
+export type TrackUserActivityResponses = {
+    /**
+     * Activity tracked
+     */
+    204: void;
+};
+export type TrackUserActivityResponse = TrackUserActivityResponses[keyof TrackUserActivityResponses];
 export type GetUserActivityHeatmapData = {
     body?: never;
     path?: never;
@@ -3677,7 +3744,7 @@ export type GetUserActivityHeatmapData = {
 };
 export type GetUserActivityHeatmapErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -3692,9 +3759,9 @@ export type GetUserActivityHeatmapResponses = {
      */
     200: {
         /**
-         * Map of YYYY-MM-DD date strings to activity counts
+         * Map of YYYY-MM-DD date strings to activity activityByDay
          */
-        counts: {
+        activityByDay: {
             [key: string]: number;
         };
     };
@@ -3713,7 +3780,7 @@ export type GetUserActivityStatsData = {
 };
 export type GetUserActivityStatsErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -3731,10 +3798,6 @@ export type GetUserActivityStatsResponses = {
         totalExports: number;
         totalPlays: number;
         totalListAdds: number;
-        /**
-         * Consecutive days with at least one activity
-         */
-        streakDays: number;
         topMedia: Array<{
             mediaId: number;
             count: number;
@@ -3742,6 +3805,70 @@ export type GetUserActivityStatsResponses = {
     };
 };
 export type GetUserActivityStatsResponse = GetUserActivityStatsResponses[keyof GetUserActivityStatsResponses];
+export type DeleteUserActivityByDateData = {
+    body?: never;
+    path: {
+        /**
+         * Date in YYYY-MM-DD format
+         */
+        date: string;
+    };
+    query?: never;
+    url: '/v1/user/activity/date/{date}';
+};
+export type DeleteUserActivityByDateErrors = {
+    /**
+     * Unauthorized (session)
+     */
+    401: Error401;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type DeleteUserActivityByDateError = DeleteUserActivityByDateErrors[keyof DeleteUserActivityByDateErrors];
+export type DeleteUserActivityByDateResponses = {
+    /**
+     * OK
+     */
+    200: {
+        deletedCount: number;
+    };
+};
+export type DeleteUserActivityByDateResponse = DeleteUserActivityByDateResponses[keyof DeleteUserActivityByDateResponses];
+export type DeleteUserActivityByIdData = {
+    body?: never;
+    path: {
+        /**
+         * Activity record ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/user/activity/{id}';
+};
+export type DeleteUserActivityByIdErrors = {
+    /**
+     * Unauthorized (session)
+     */
+    401: Error401;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type DeleteUserActivityByIdError = DeleteUserActivityByIdErrors[keyof DeleteUserActivityByIdErrors];
+export type DeleteUserActivityByIdResponses = {
+    /**
+     * Activity deleted
+     */
+    204: void;
+};
+export type DeleteUserActivityByIdResponse = DeleteUserActivityByIdResponses[keyof DeleteUserActivityByIdResponses];
 export type ExportUserDataData = {
     body?: never;
     path?: never;
@@ -3750,7 +3877,7 @@ export type ExportUserDataData = {
 };
 export type ExportUserDataErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -3774,7 +3901,7 @@ export type ListUserLabsData = {
 };
 export type ListUserLabsErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -3790,6 +3917,72 @@ export type ListUserLabsResponses = {
     200: Array<UserLabFeature>;
 };
 export type ListUserLabsResponse = ListUserLabsResponses[keyof ListUserLabsResponses];
+export type UnenrollUserLabData = {
+    body?: never;
+    path: {
+        /**
+         * Lab feature key
+         */
+        key: string;
+    };
+    query?: never;
+    url: '/v1/user/labs/{key}';
+};
+export type UnenrollUserLabErrors = {
+    /**
+     * Unauthorized (session)
+     */
+    401: Error401;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type UnenrollUserLabError = UnenrollUserLabErrors[keyof UnenrollUserLabErrors];
+export type UnenrollUserLabResponses = {
+    /**
+     * Unenrolled successfully
+     */
+    204: void;
+};
+export type UnenrollUserLabResponse = UnenrollUserLabResponses[keyof UnenrollUserLabResponses];
+export type EnrollUserLabData = {
+    body?: never;
+    path: {
+        /**
+         * Lab feature key
+         */
+        key: string;
+    };
+    query?: never;
+    url: '/v1/user/labs/{key}';
+};
+export type EnrollUserLabErrors = {
+    /**
+     * Unauthorized (session)
+     */
+    401: Error401;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type EnrollUserLabError = EnrollUserLabErrors[keyof EnrollUserLabErrors];
+export type EnrollUserLabResponses = {
+    /**
+     * Enrolled successfully
+     */
+    204: void;
+};
+export type EnrollUserLabResponse = EnrollUserLabResponses[keyof EnrollUserLabResponses];
 export type ListCollectionsData = {
     body?: never;
     path?: never;
@@ -3799,19 +3992,13 @@ export type ListCollectionsData = {
          */
         visibility?: 'public' | 'private';
         /**
-         * Cursor offset for pagination
-         */
-        cursor?: number;
-        /**
-         * Page number (1-indexed)
-         *
-         * @deprecated
+         * Opaque pagination cursor token
          */
-        page?: number;
+        cursor?: string;
         /**
          * Items per page
          */
-        limit?: number;
+        take?: number;
     };
     url: '/v1/collections';
 };
@@ -3821,7 +4008,7 @@ export type ListCollectionsErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -3857,7 +4044,7 @@ export type CreateCollectionErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -3898,7 +4085,7 @@ export type DeleteCollectionErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -3936,19 +4123,13 @@ export type GetCollectionData = {
     };
     query?: {
         /**
-         * Cursor offset for paginated segments
+         * Opaque pagination cursor token for paginated segments
          */
-        cursor?: number;
-        /**
-         * Page number (1-indexed)
-         *
-         * @deprecated
-         */
-        page?: number;
+        cursor?: string;
         /**
          * Items per page
          */
-        limit?: number;
+        take?: number;
     };
     url: '/v1/collections/{id}';
 };
@@ -3958,7 +4139,7 @@ export type GetCollectionErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -4006,7 +4187,7 @@ export type UpdateCollectionErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -4037,11 +4218,114 @@ export type UpdateCollectionResponse = UpdateCollectionResponses[keyof UpdateCol
 export type AddSegmentToCollectionData = {
     body: {
         /**
-         * UUID of the segment to add
+         * UUID of the segment to add
+         */
+        segmentUuid: string;
+        /**
+         * Optional annotation
+         */
+        note?: string;
+    };
+    path: {
+        /**
+         * Collection ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/collections/{id}/segments';
+};
+export type AddSegmentToCollectionErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized (session)
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AddSegmentToCollectionError = AddSegmentToCollectionErrors[keyof AddSegmentToCollectionErrors];
+export type AddSegmentToCollectionResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type AddSegmentToCollectionResponse = AddSegmentToCollectionResponses[keyof AddSegmentToCollectionResponses];
+export type RemoveSegmentFromCollectionData = {
+    body?: never;
+    path: {
+        /**
+         * Collection ID
+         */
+        id: number;
+        /**
+         * Segment UUID
+         */
+        uuid: string;
+    };
+    query?: never;
+    url: '/v1/collections/{id}/segments/{uuid}';
+};
+export type RemoveSegmentFromCollectionErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized (session)
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type RemoveSegmentFromCollectionError = RemoveSegmentFromCollectionErrors[keyof RemoveSegmentFromCollectionErrors];
+export type RemoveSegmentFromCollectionResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type RemoveSegmentFromCollectionResponse = RemoveSegmentFromCollectionResponses[keyof RemoveSegmentFromCollectionResponses];
+export type UpdateCollectionSegmentData = {
+    body: {
+        /**
+         * New position in the collection
          */
-        segmentUuid: string;
+        position?: number;
         /**
-         * Optional annotation
+         * Updated annotation
          */
         note?: string;
     };
@@ -4050,17 +4334,21 @@ export type AddSegmentToCollectionData = {
          * Collection ID
          */
         id: number;
+        /**
+         * Segment UUID
+         */
+        uuid: string;
     };
     query?: never;
-    url: '/v1/collections/{id}/segments';
+    url: '/v1/collections/{id}/segments/{uuid}';
 };
-export type AddSegmentToCollectionErrors = {
+export type UpdateCollectionSegmentErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -4080,36 +4368,41 @@ export type AddSegmentToCollectionErrors = {
      */
     500: Error500;
 };
-export type AddSegmentToCollectionError = AddSegmentToCollectionErrors[keyof AddSegmentToCollectionErrors];
-export type AddSegmentToCollectionResponses = {
+export type UpdateCollectionSegmentError = UpdateCollectionSegmentErrors[keyof UpdateCollectionSegmentErrors];
+export type UpdateCollectionSegmentResponses = {
     /**
      * No Content
      */
     204: void;
 };
-export type AddSegmentToCollectionResponse = AddSegmentToCollectionResponses[keyof AddSegmentToCollectionResponses];
-export type RemoveSegmentFromCollectionData = {
+export type UpdateCollectionSegmentResponse = UpdateCollectionSegmentResponses[keyof UpdateCollectionSegmentResponses];
+export type SearchCollectionSegmentsData = {
     body?: never;
     path: {
         /**
          * Collection ID
          */
         id: number;
+    };
+    query?: {
         /**
-         * Segment UUID
+         * Opaque cursor token for pagination
          */
-        uuid: string;
+        cursor?: string;
+        /**
+         * Items per page
+         */
+        take?: number;
     };
-    query?: never;
-    url: '/v1/collections/{id}/segments/{uuid}';
+    url: '/v1/collections/{id}/search';
 };
-export type RemoveSegmentFromCollectionErrors = {
+export type SearchCollectionSegmentsErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -4129,45 +4422,32 @@ export type RemoveSegmentFromCollectionErrors = {
      */
     500: Error500;
 };
-export type RemoveSegmentFromCollectionError = RemoveSegmentFromCollectionErrors[keyof RemoveSegmentFromCollectionErrors];
-export type RemoveSegmentFromCollectionResponses = {
+export type SearchCollectionSegmentsError = SearchCollectionSegmentsErrors[keyof SearchCollectionSegmentsErrors];
+export type SearchCollectionSegmentsResponses = {
     /**
-     * No Content
+     * OK
      */
-    204: void;
+    200: SearchResponse;
 };
-export type RemoveSegmentFromCollectionResponse = RemoveSegmentFromCollectionResponses[keyof RemoveSegmentFromCollectionResponses];
-export type UpdateCollectionSegmentData = {
-    body: {
-        /**
-         * New position in the collection
-         */
-        position?: number;
-        /**
-         * Updated annotation
-         */
-        note?: string;
-    };
+export type SearchCollectionSegmentsResponse = SearchCollectionSegmentsResponses[keyof SearchCollectionSegmentsResponses];
+export type GetCollectionStatsData = {
+    body?: never;
     path: {
         /**
          * Collection ID
          */
         id: number;
-        /**
-         * Segment UUID
-         */
-        uuid: string;
     };
     query?: never;
-    url: '/v1/collections/{id}/segments/{uuid}';
+    url: '/v1/collections/{id}/stats';
 };
-export type UpdateCollectionSegmentErrors = {
+export type GetCollectionStatsErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -4187,14 +4467,14 @@ export type UpdateCollectionSegmentErrors = {
      */
     500: Error500;
 };
-export type UpdateCollectionSegmentError = UpdateCollectionSegmentErrors[keyof UpdateCollectionSegmentErrors];
-export type UpdateCollectionSegmentResponses = {
+export type GetCollectionStatsError = GetCollectionStatsErrors[keyof GetCollectionStatsErrors];
+export type GetCollectionStatsResponses = {
     /**
-     * No Content
+     * OK
      */
-    204: void;
+    200: SearchStatsResponse;
 };
-export type UpdateCollectionSegmentResponse = UpdateCollectionSegmentResponses[keyof UpdateCollectionSegmentResponses];
+export type GetCollectionStatsResponse = GetCollectionStatsResponses[keyof GetCollectionStatsResponses];
 export type GetAdminDashboardData = {
     body?: never;
     path?: never;
@@ -4203,7 +4483,7 @@ export type GetAdminDashboardData = {
 };
 export type GetAdminDashboardErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -4295,7 +4575,7 @@ export type GetAdminHealthData = {
 };
 export type GetAdminHealthErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -4357,7 +4637,7 @@ export type TriggerReindexErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -4393,7 +4673,7 @@ export type ListAdminQueueStatsErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -4415,15 +4695,15 @@ export type ListAdminQueueStatsResponses = {
      * Queue statistics retrieved successfully
      */
     200: Array<{
-        queue?: string;
+        queue: string;
         /**
          * Number of jobs currently pending/active
          */
-        stuckCount?: number;
+        stuckCount: number;
         /**
          * Number of failed jobs
          */
-        failedCount?: number;
+        failedCount: number;
     }>;
 };
 export type ListAdminQueueStatsResponse = ListAdminQueueStatsResponses[keyof ListAdminQueueStatsResponses];
@@ -4444,7 +4724,7 @@ export type GetAdminQueueErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -4529,7 +4809,7 @@ export type ListAdminQueueFailedErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -4554,19 +4834,19 @@ export type ListAdminQueueFailedResponses = {
         /**
          * Job ID
          */
-        id?: string;
+        id: string;
         /**
          * The segment ID that failed to sync
          */
-        segmentId?: number;
+        segmentId: number;
         /**
          * Error message from the last attempt
          */
-        error?: string;
+        error: string;
         /**
          * When the job was created
          */
-        createdOn?: string;
+        createdOn: string;
     }>;
 };
 export type ListAdminQueueFailedResponse = ListAdminQueueFailedResponses[keyof ListAdminQueueFailedResponses];
@@ -4587,7 +4867,7 @@ export type RetryAdminQueueFailedErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -4609,12 +4889,12 @@ export type RetryAdminQueueFailedResponses = {
      * Jobs queued for retry
      */
     200: {
-        success?: boolean;
+        success: boolean;
         /**
          * Number of jobs queued for retry
          */
-        retriedCount?: number;
-        message?: string;
+        retriedCount: number;
+        message: string;
     };
 };
 export type RetryAdminQueueFailedResponse = RetryAdminQueueFailedResponses[keyof RetryAdminQueueFailedResponses];
@@ -4635,7 +4915,7 @@ export type PurgeAdminQueueFailedErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -4657,27 +4937,113 @@ export type PurgeAdminQueueFailedResponses = {
      * Failed jobs purged successfully
      */
     200: {
-        success?: boolean;
+        success: boolean;
         /**
          * Number of failed jobs deleted
          */
-        purgedCount?: number;
-        message?: string;
+        purgedCount: number;
+        message: string;
     };
 };
 export type PurgeAdminQueueFailedResponse = PurgeAdminQueueFailedResponses[keyof PurgeAdminQueueFailedResponses];
+export type ClearAdminImpersonationData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/admin/impersonation';
+};
+export type ClearAdminImpersonationErrors = {
+    /**
+     * Unauthorized (session)
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type ClearAdminImpersonationError = ClearAdminImpersonationErrors[keyof ClearAdminImpersonationErrors];
+export type ClearAdminImpersonationResponses = {
+    /**
+     * Impersonation session cleared
+     */
+    200: {
+        message: string;
+    };
+};
+export type ClearAdminImpersonationResponse = ClearAdminImpersonationResponses[keyof ClearAdminImpersonationResponses];
+export type ImpersonateAdminUserData = {
+    body: {
+        /**
+         * User ID to impersonate
+         */
+        userId: number;
+    };
+    path?: never;
+    query?: never;
+    url: '/v1/admin/impersonation';
+};
+export type ImpersonateAdminUserErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized (session)
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type ImpersonateAdminUserError = ImpersonateAdminUserErrors[keyof ImpersonateAdminUserErrors];
+export type ImpersonateAdminUserResponses = {
+    /**
+     * Impersonation session created
+     */
+    200: {
+        message: string;
+        user: {
+            id: number;
+            username: string;
+            email: string;
+        };
+    };
+};
+export type ImpersonateAdminUserResponse = ImpersonateAdminUserResponses[keyof ImpersonateAdminUserResponses];
 export type ListAdminReportsData = {
     body?: never;
     path?: never;
     query?: {
         /**
-         * Cursor for pagination (report ID to start after)
+         * Opaque pagination cursor token
          */
-        cursor?: number;
+        cursor?: string;
         /**
          * Number of results per page
          */
-        limit?: number;
+        take?: number;
         /**
          * Filter by report status
          */
@@ -4703,15 +5069,15 @@ export type ListAdminReportsData = {
          */
         'target.segmentUuid'?: string;
         /**
-         * Filter by review check run ID
+         * Filter by audit run ID
          */
-        reviewCheckRunId?: number;
+        auditRunId?: number;
     };
     url: '/v1/admin/reports';
 };
 export type ListAdminReportsErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -4752,7 +5118,7 @@ export type UpdateAdminReportErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -4780,56 +5146,15 @@ export type UpdateAdminReportResponses = {
     200: Report;
 };
 export type UpdateAdminReportResponse = UpdateAdminReportResponses[keyof UpdateAdminReportResponses];
-export type RunAdminReviewData = {
-    body?: never;
-    path?: never;
-    query?: {
-        /**
-         * Optional category filter
-         */
-        category?: 'ANIME' | 'JDRAMA';
-        /**
-         * Optional check name to run a single check instead of all
-         */
-        checkName?: string;
-    };
-    url: '/v1/admin/review/run';
-};
-export type RunAdminReviewErrors = {
-    /**
-     * Unauthorized
-     */
-    401: Error401;
-    /**
-     * Forbidden
-     */
-    403: Error403;
-    /**
-     * Too Many Requests
-     */
-    429: Error429;
-    /**
-     * Internal Server Error
-     */
-    500: Error500;
-};
-export type RunAdminReviewError = RunAdminReviewErrors[keyof RunAdminReviewErrors];
-export type RunAdminReviewResponses = {
-    /**
-     * Check run completed
-     */
-    200: RunReviewResponse;
-};
-export type RunAdminReviewResponse = RunAdminReviewResponses[keyof RunAdminReviewResponses];
-export type ListAdminReviewChecksData = {
+export type ListAdminMediaAuditsData = {
     body?: never;
     path?: never;
     query?: never;
-    url: '/v1/admin/review/checks';
+    url: '/v1/admin/media/audits';
 };
-export type ListAdminReviewChecksErrors = {
+export type ListAdminMediaAuditsErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -4845,15 +5170,15 @@ export type ListAdminReviewChecksErrors = {
      */
     500: Error500;
 };
-export type ListAdminReviewChecksError = ListAdminReviewChecksErrors[keyof ListAdminReviewChecksErrors];
-export type ListAdminReviewChecksResponses = {
+export type ListAdminMediaAuditsError = ListAdminMediaAuditsErrors[keyof ListAdminMediaAuditsErrors];
+export type ListAdminMediaAuditsResponses = {
     /**
      * OK
      */
-    200: Array<ReviewCheck>;
+    200: Array<MediaAudit>;
 };
-export type ListAdminReviewChecksResponse = ListAdminReviewChecksResponses[keyof ListAdminReviewChecksResponses];
-export type UpdateAdminReviewCheckData = {
+export type ListAdminMediaAuditsResponse = ListAdminMediaAuditsResponses[keyof ListAdminMediaAuditsResponses];
+export type UpdateAdminMediaAuditData = {
     body: {
         /**
          * New threshold values
@@ -4862,26 +5187,26 @@ export type UpdateAdminReviewCheckData = {
             [key: string]: unknown;
         };
         /**
-         * Enable or disable this check
+         * Enable or disable this audit
          */
         enabled?: boolean;
     };
     path: {
         /**
-         * Check name identifier
+         * Audit name identifier
          */
         name: string;
     };
     query?: never;
-    url: '/v1/admin/review/checks/{name}';
+    url: '/v1/admin/media/audits/{name}';
 };
-export type UpdateAdminReviewCheckErrors = {
+export type UpdateAdminMediaAuditErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -4901,76 +5226,33 @@ export type UpdateAdminReviewCheckErrors = {
      */
     500: Error500;
 };
-export type UpdateAdminReviewCheckError = UpdateAdminReviewCheckErrors[keyof UpdateAdminReviewCheckErrors];
-export type UpdateAdminReviewCheckResponses = {
+export type UpdateAdminMediaAuditError = UpdateAdminMediaAuditErrors[keyof UpdateAdminMediaAuditErrors];
+export type UpdateAdminMediaAuditResponses = {
     /**
-     * Check updated successfully
+     * Audit updated successfully
      */
-    200: ReviewCheck;
+    200: MediaAudit;
 };
-export type UpdateAdminReviewCheckResponse = UpdateAdminReviewCheckResponses[keyof UpdateAdminReviewCheckResponses];
-export type ListAdminReviewRunsData = {
+export type UpdateAdminMediaAuditResponse = UpdateAdminMediaAuditResponses[keyof UpdateAdminMediaAuditResponses];
+export type RunAdminMediaAuditData = {
     body?: never;
-    path?: never;
-    query?: {
-        /**
-         * Filter by check name
-         */
-        checkName?: string;
-        /**
-         * Cursor for pagination
-         */
-        cursor?: number;
+    path: {
         /**
-         * Number of results per page
+         * Audit name to run, or "all" to run all enabled audits
          */
-        limit?: number;
-    };
-    url: '/v1/admin/review/runs';
-};
-export type ListAdminReviewRunsErrors = {
-    /**
-     * Unauthorized
-     */
-    401: Error401;
-    /**
-     * Forbidden
-     */
-    403: Error403;
-    /**
-     * Too Many Requests
-     */
-    429: Error429;
-    /**
-     * Internal Server Error
-     */
-    500: Error500;
-};
-export type ListAdminReviewRunsError = ListAdminReviewRunsErrors[keyof ListAdminReviewRunsErrors];
-export type ListAdminReviewRunsResponses = {
-    /**
-     * OK
-     */
-    200: {
-        runs: Array<ReviewCheckRun>;
-        pagination: CursorPagination;
+        name: string;
     };
-};
-export type ListAdminReviewRunsResponse = ListAdminReviewRunsResponses[keyof ListAdminReviewRunsResponses];
-export type GetAdminReviewRunData = {
-    body?: never;
-    path: {
+    query?: {
         /**
-         * Run ID
+         * Optional category filter
          */
-        id: number;
+        category?: 'ANIME' | 'JDRAMA';
     };
-    query?: never;
-    url: '/v1/admin/review/runs/{id}';
+    url: '/v1/admin/media/audits/{name}/run';
 };
-export type GetAdminReviewRunErrors = {
+export type RunAdminMediaAuditErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -4990,94 +5272,42 @@ export type GetAdminReviewRunErrors = {
      */
     500: Error500;
 };
-export type GetAdminReviewRunError = GetAdminReviewRunErrors[keyof GetAdminReviewRunErrors];
-export type GetAdminReviewRunResponses = {
+export type RunAdminMediaAuditError = RunAdminMediaAuditErrors[keyof RunAdminMediaAuditErrors];
+export type RunAdminMediaAuditResponses = {
     /**
-     * OK
+     * Audit run completed
      */
-    200: {
-        run: ReviewCheckRun;
-        reports: Array<Report>;
-    };
+    200: RunAuditResponse;
 };
-export type GetAdminReviewRunResponse = GetAdminReviewRunResponses[keyof GetAdminReviewRunResponses];
-export type ListAdminReviewAllowlistData = {
+export type RunAdminMediaAuditResponse = RunAdminMediaAuditResponses[keyof RunAdminMediaAuditResponses];
+export type ListAdminMediaAuditRunsData = {
     body?: never;
     path?: never;
     query?: {
         /**
-         * Filter by check name
-         */
-        checkName?: string;
-    };
-    url: '/v1/admin/review/allowlist';
-};
-export type ListAdminReviewAllowlistErrors = {
-    /**
-     * Unauthorized
-     */
-    401: Error401;
-    /**
-     * Forbidden
-     */
-    403: Error403;
-    /**
-     * Too Many Requests
-     */
-    429: Error429;
-    /**
-     * Internal Server Error
-     */
-    500: Error500;
-};
-export type ListAdminReviewAllowlistError = ListAdminReviewAllowlistErrors[keyof ListAdminReviewAllowlistErrors];
-export type ListAdminReviewAllowlistResponses = {
-    /**
-     * OK
-     */
-    200: Array<ReviewAllowlist>;
-};
-export type ListAdminReviewAllowlistResponse = ListAdminReviewAllowlistResponses[keyof ListAdminReviewAllowlistResponses];
-export type CreateAdminReviewAllowlistEntryData = {
-    body: {
-        /**
-         * Check name to allowlist for
-         */
-        checkName: string;
-        /**
-         * Media ID to allowlist
+         * Filter by audit name
          */
-        mediaId: number;
+        auditName?: string;
         /**
-         * Episode number (for episode-level checks)
+         * Opaque pagination cursor token
          */
-        episodeNumber?: number;
+        cursor?: string;
         /**
-         * Reason for allowlisting
+         * Number of results per page
          */
-        reason?: string;
+        take?: number;
     };
-    path?: never;
-    query?: never;
-    url: '/v1/admin/review/allowlist';
+    url: '/v1/admin/media/audits/runs';
 };
-export type CreateAdminReviewAllowlistEntryErrors = {
-    /**
-     * Bad Request
-     */
-    400: Error400;
+export type ListAdminMediaAuditRunsErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
      * Forbidden
      */
     403: Error403;
-    /**
-     * Conflict
-     */
-    409: Error409;
     /**
      * Too Many Requests
      */
@@ -5087,28 +5317,31 @@ export type CreateAdminReviewAllowlistEntryErrors = {
      */
     500: Error500;
 };
-export type CreateAdminReviewAllowlistEntryError = CreateAdminReviewAllowlistEntryErrors[keyof CreateAdminReviewAllowlistEntryErrors];
-export type CreateAdminReviewAllowlistEntryResponses = {
+export type ListAdminMediaAuditRunsError = ListAdminMediaAuditRunsErrors[keyof ListAdminMediaAuditRunsErrors];
+export type ListAdminMediaAuditRunsResponses = {
     /**
-     * Added to allowlist
+     * OK
      */
-    201: ReviewAllowlist;
+    200: {
+        runs: Array<MediaAuditRun>;
+        pagination: OpaqueCursorPagination;
+    };
 };
-export type CreateAdminReviewAllowlistEntryResponse = CreateAdminReviewAllowlistEntryResponses[keyof CreateAdminReviewAllowlistEntryResponses];
-export type DeleteAdminReviewAllowlistEntryData = {
+export type ListAdminMediaAuditRunsResponse = ListAdminMediaAuditRunsResponses[keyof ListAdminMediaAuditRunsResponses];
+export type GetAdminMediaAuditRunData = {
     body?: never;
     path: {
         /**
-         * Allowlist entry ID
+         * Run ID
          */
         id: number;
     };
     query?: never;
-    url: '/v1/admin/review/allowlist/{id}';
+    url: '/v1/admin/media/audits/runs/{id}';
 };
-export type DeleteAdminReviewAllowlistEntryErrors = {
+export type GetAdminMediaAuditRunErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -5128,12 +5361,15 @@ export type DeleteAdminReviewAllowlistEntryErrors = {
      */
     500: Error500;
 };
-export type DeleteAdminReviewAllowlistEntryError = DeleteAdminReviewAllowlistEntryErrors[keyof DeleteAdminReviewAllowlistEntryErrors];
-export type DeleteAdminReviewAllowlistEntryResponses = {
+export type GetAdminMediaAuditRunError = GetAdminMediaAuditRunErrors[keyof GetAdminMediaAuditRunErrors];
+export type GetAdminMediaAuditRunResponses = {
     /**
-     * Removed from allowlist
+     * OK
      */
-    204: void;
+    200: {
+        run: MediaAuditRun;
+        reports: Array<Report>;
+    };
 };
-export type DeleteAdminReviewAllowlistEntryResponse = DeleteAdminReviewAllowlistEntryResponses[keyof DeleteAdminReviewAllowlistEntryResponses];
+export type GetAdminMediaAuditRunResponse = GetAdminMediaAuditRunResponses[keyof GetAdminMediaAuditRunResponses];
 //# sourceMappingURL=types.gen.d.ts.map