@brigadasos/nadeshiko-sdk 1.4.3-dev.e5c01f0 → 1.5.0-dev.220bc0b

package/dist/types.gen.d.ts

@@ -1,14 +1,14 @@
 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
  */
 export type MediaFilterItem = {
     /**
-     * Media ID to filter
+     * Media identifier (publicId or AniList external ID)
      */
-    mediaId: number;
+    mediaId: string;
     /**
      * Specific episodes (omit for all episodes)
      */
@@ -108,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
      */
@@ -144,6 +144,10 @@ export type Segment = {
      * Unique identifier for the segment
      */
     uuid: string;
+    /**
+     * Public identifier for the segment (use this instead of uuid in public URLs)
+     */
+    publicId: string;
     /**
      * Position of the segment within the episode
      */
@@ -169,6 +173,10 @@ export type Segment = {
      * Media ID this segment belongs to
      */
     mediaId: number;
+    /**
+     * Public ID of the media this segment belongs to
+     */
+    mediaPublicId: string;
     textJa: {
         /**
          * Original Japanese content
@@ -241,15 +249,24 @@ export type ExternalId = {
      * TVDB ID
      */
     tvdb?: string;
+    /**
+     * TMDB ID
+     */
+    tmdb?: string;
 };
 /**
  * Japanese voice actor (seiyuu)
  */
 export type Seiyuu = {
     /**
-     * AniList staff ID
+     * Internal seiyuu ID
      */
     id: number;
+    /**
+     * Public identifier for the seiyuu (use this in public URLs)
+     */
+    publicId: string;
+    externalIds: ExternalId;
     /**
      * Japanese name of the voice actor
      */
@@ -294,9 +311,13 @@ export type MediaCharacter = {
  */
 export type Media = {
     /**
-     * Unique identifier for the media
+     * Internal unique identifier for the media
      */
     id: number;
+    /**
+     * Public identifier for the media (use this in public URLs)
+     */
+    publicId: string;
     externalIds: ExternalId;
     /**
      * Original Japanese name of the media
@@ -350,7 +371,7 @@ export type Media = {
     /**
      * Animation studio that produced the media
      */
-    studio: string;
+    studio?: string;
     /**
      * Airing season label for the media
      */
@@ -371,31 +392,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 objects keyed by media publicId
          */
-        media?: {
+        media: {
             [key: string]: Media;
         };
     };
-    pagination?: PaginationInfo;
+    pagination: PaginationInfo;
 };
 /**
  * Bad Request error response
@@ -600,6 +621,10 @@ export type MediaSearchStats = {
      * Media identifier (look up full details in includes.media)
      */
     mediaId: number;
+    /**
+     * Public identifier for use in URLs and filters
+     */
+    publicId: string;
     /**
      * Number of matching segments found in this media
      */
@@ -615,20 +640,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 objects keyed by media publicId
          */
-        media?: {
+        media: {
             [key: string]: Media;
         };
     };
@@ -673,27 +698,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;
         };
     };
@@ -701,32 +726,43 @@ 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;
+    stats: {
+        /**
+         * Total number of media across all pages
+         */
+        totalMedia: number;
+        /**
+         * Total number of non-deleted segments
+         */
+        totalSegments: number;
+        /**
+         * Total number of episodes
+         */
+        totalEpisodes: number;
+    };
 };
 /**
  * Character data for creating/updating media
  */
 export type CharacterInput = {
-    /**
-     * AniList character ID
-     */
-    id: number;
+    externalIds: ExternalId;
     /**
      * Japanese name of the character
      */
@@ -743,22 +779,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
@@ -816,7 +851,7 @@ export type MediaCreateRequest = {
     /**
      * Animation studio that produced the media
      */
-    studio: string;
+    studio?: string;
     /**
      * Airing season label for the media
      */
@@ -869,8 +904,65 @@ export type Error409 = {
         [key: string]: string;
     };
 };
+/**
+ * Slim media item returned by autocomplete (names + cover only)
+ */
+export type MediaAutocompleteItem = {
+    /**
+     * Unique identifier for the media
+     */
+    id: number;
+    /**
+     * Original Japanese name of the media
+     */
+    nameJa: string;
+    /**
+     * Romaji transliteration of the media name
+     */
+    nameRomaji: string;
+    /**
+     * English name of the media
+     */
+    nameEn: string;
+    /**
+     * Full URL to the cover image
+     */
+    coverUrl: string;
+    category: Category;
+};
 export type MediaAutocompleteResponse = {
-    media: Array<Media>;
+    media: Array<MediaAutocompleteItem>;
+};
+/**
+ * Segment with internal fields. For write operations (create, update) all fields are always populated.
+ * For GET, optional fields are only populated when requested via include[].
+ *
+ */
+export type SegmentInternal = Segment & {
+    /**
+     * Storage backend for segment assets
+     */
+    storage?: 'LOCAL' | 'R2';
+    /**
+     * Hash identifier for the segment
+     */
+    hashedId?: string;
+    /**
+     * Base path in the storage backend
+     */
+    storageBasePath?: string;
+    /**
+     * 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;
+    };
 };
 /**
  * Not Found error response
@@ -908,104 +1000,341 @@ export type Error404 = {
     };
 };
 /**
- * Request body for updating an existing media entry (all fields optional)
+ * All fields are optional for partial updates
  */
-export type MediaUpdateRequest = {
-    externalIds?: ExternalId;
+export type SegmentUpdateRequest = {
     /**
-     * Original Japanese name of the media
+     * Position of the segment within the episode
      */
-    nameJa?: string;
+    position?: number;
     /**
-     * Romaji transliteration of the media name
+     * Segment status
      */
-    nameRomaji?: string;
+    status?: 'DELETED' | 'ACTIVE' | 'SUSPENDED' | 'VERIFIED' | 'INVALID' | 'TOO_LONG';
     /**
-     * English name of the media
+     * Start time of the segment in milliseconds from the beginning of the episode
      */
-    nameEn?: string;
+    startTimeMs?: number;
     /**
-     * Format of the media release (e.g., TV, OVA, Movie)
+     * End time of the segment in milliseconds from the beginning of the episode
      */
-    airingFormat?: string;
+    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;
     /**
-     * Current airing status (FINISHED, RELEASING, NOT_YET_RELEASED, CANCELLED)
+     * Raw WD Tagger v3 classifier output used to derive content rating
      */
-    airingStatus?: string;
+    ratingAnalysis?: {
+        [key: string]: unknown;
+    };
     /**
-     * List of genres associated with the media
+     * POS tokenization results keyed by engine (sudachi, unidic)
      */
-    genres?: Array<string>;
+    posAnalysis?: {
+        [key: string]: unknown;
+    };
     /**
-     * Storage backend for media assets
+     * Storage backend for segment assets
      */
     storage?: 'LOCAL' | 'R2';
     /**
-     * Start date of the media (first airing/release)
+     * Hash identifier for the segment (from segment JSON)
      */
-    startDate?: string;
+    hashedId?: string;
+};
+export type SegmentContextResponse = {
+    segments: Array<Segment>;
+    includes: {
+        /**
+         * Media objects keyed by mediaId
+         */
+        media?: {
+            [key: string]: Media;
+        };
+    };
+};
+export type SegmentRevision = {
     /**
-     * End date of the media (last airing/release)
+     * Revision ID
      */
-    endDate?: string;
+    id: number;
     /**
-     * Media category
+     * Sequential revision number per segment
      */
-    category?: 'ANIME' | 'JDRAMA';
+    revisionNumber: number;
     /**
-     * Version of the media-sub-splitter used
+     * Snapshot of editable fields at the time of the revision
      */
-    version?: string;
+    snapshot: {
+        [key: string]: unknown;
+    };
     /**
-     * Hash salt used when generating the hash for the related media assets
+     * Name of the user who made the change
      */
-    hashSalt?: string;
+    userName?: string;
     /**
-     * Animation studio that produced the media
+     * When the revision was created
      */
-    studio?: string;
+    createdAt: string;
+};
+/**
+ * Ordered media series grouping
+ */
+export type Series = {
     /**
-     * Airing season label for the media
+     * Series ID
      */
-    seasonName?: string;
+    id: number;
     /**
-     * Airing year for the media
+     * Public identifier for the series
      */
-    seasonYear?: number;
+    publicId: string;
     /**
-     * Base path for R2/CDN storage (e.g. "media/21459")
+     * Japanese name of the series
      */
-    storageBasePath?: string;
+    nameJa: string;
     /**
-     * List of characters appearing in the media with their voice actors
+     * Romaji name of the series
      */
-    characters?: Array<CharacterInput>;
+    nameRomaji: string;
     /**
-     * Total number of subtitle segments available
+     * English name of the series
      */
-    segmentCount?: number;
+    nameEn: string;
 };
-export type Episode = {
+export type SeriesListResponse = {
+    series: Array<Series>;
+    pagination: OpaqueCursorPagination;
+};
+/**
+ * Series with ordered media entries
+ */
+export type SeriesWithMedia = {
     /**
-     * ID of the media this episode belongs to
+     * Series ID
      */
-    mediaId: number;
+    id: number;
     /**
-     * Episode number within the media
+     * Japanese name of the series
      */
-    episodeNumber: number;
+    nameJa: string;
     /**
-     * English title of the episode
+     * Romaji name of the series
      */
-    titleEn?: string;
+    nameRomaji: string;
     /**
-     * Romanized title of the episode
+     * English name of the series
      */
-    titleRomaji?: string;
+    nameEn: string;
     /**
-     * Japanese title of the episode
+     * All media in the series, sorted by position
      */
-    titleJa?: string;
+    media: Array<{
+        /**
+         * Position in the series (1-indexed)
+         */
+        position: number;
+        media: Media;
+    }>;
+};
+/**
+ * Anime character
+ */
+export type Character = {
+    /**
+     * Internal character ID
+     */
+    id: number;
+    /**
+     * Public identifier for the character (use this in public URLs)
+     */
+    publicId: string;
+    externalIds: ExternalId;
+    /**
+     * Japanese name of the character
+     */
+    nameJa: string;
+    /**
+     * English name of the character
+     */
+    nameEn: string;
+    /**
+     * Character image URL
+     */
+    imageUrl: string;
+};
+/**
+ * Character with voice actor and all media appearances
+ */
+export type CharacterWithMedia = Character & {
+    seiyuu: Seiyuu;
+    /**
+     * All media this character appears in
+     */
+    mediaAppearances: Array<{
+        media: Media;
+        /**
+         * Character role in this media
+         */
+        role: 'MAIN' | 'SUPPORTING' | 'BACKGROUND';
+    }>;
+};
+/**
+ * Seiyuu details with optional character appearances
+ */
+export type SeiyuuWithRoles = {
+    /**
+     * AniList staff ID
+     */
+    id: number;
+    externalIds: ExternalId;
+    /**
+     * Japanese name of the voice actor
+     */
+    nameJa: string;
+    /**
+     * 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
      */
@@ -1032,7 +1361,7 @@ export type EpisodeListResponse = {
      * Array of episode objects
      */
     episodes: Array<Episode>;
-    pagination: CursorPagination;
+    pagination: OpaqueCursorPagination;
 };
 export type EpisodeCreateRequest = {
     /**
@@ -1166,237 +1495,8 @@ export type SegmentCreateRequest = {
      */
     hashedId: string;
 };
-/**
- * Segment with internal fields (for internal API responses)
- */
-export type SegmentInternal = Segment & {
-    /**
-     * Storage backend for segment assets
-     */
-    storage?: 'LOCAL' | 'R2';
-    /**
-     * Hash identifier for the segment
-     */
-    hashedId?: string;
-    /**
-     * Base path in the storage backend
-     */
-    storageBasePath?: string;
-    /**
-     * 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;
-    };
-};
-/**
- * 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?: {
-        /**
-         * Media objects keyed by mediaId
-         */
-        media?: {
-            [key: string]: Media;
-        };
-    };
-};
-/**
- * Ordered media series grouping
- */
-export type Series = {
-    /**
-     * Series ID
-     */
-    id: number;
-    /**
-     * Japanese name of the series
-     */
-    nameJa: string;
-    /**
-     * Romaji name of the series
-     */
-    nameRomaji: string;
-    /**
-     * English name of the series
-     */
-    nameEn: string;
-};
-export type SeriesListResponse = {
-    series: Array<Series>;
-    pagination: CursorPagination;
-};
-/**
- * Series with ordered media entries
- */
-export type SeriesWithMedia = {
-    /**
-     * Series ID
-     */
-    id: number;
-    /**
-     * Japanese name of the series
-     */
-    nameJa: string;
-    /**
-     * Romaji name of the series
-     */
-    nameRomaji: string;
-    /**
-     * English name of the series
-     */
-    nameEn: string;
-    /**
-     * All media in the series, sorted by position
-     */
-    media: Array<{
-        /**
-         * Position in the series (1-indexed)
-         */
-        position?: number;
-        media?: Media;
-    }>;
-};
-/**
- * Anime character
- */
-export type Character = {
-    /**
-     * AniList character ID
-     */
-    id: number;
-    /**
-     * Japanese name of the character
-     */
-    nameJa: string;
-    /**
-     * English name of the character
-     */
-    nameEn: string;
-    /**
-     * Character image URL
-     */
-    imageUrl: string;
-};
-/**
- * Character with voice actor and all media appearances
- */
-export type CharacterWithMedia = Character & {
-    seiyuu: Seiyuu;
-    /**
-     * All media this character appears in
-     */
-    mediaAppearances: Array<{
-        media?: Media;
-        /**
-         * Character role in this media
-         */
-        role?: 'MAIN' | 'SUPPORTING' | 'BACKGROUND';
-    }>;
-};
-/**
- * Seiyuu details with optional character appearances
- */
-export type SeiyuuWithRoles = {
-    /**
-     * AniList staff ID
-     */
-    id: number;
-    /**
-     * Japanese name of the voice actor
-     */
-    nameJa: string;
-    /**
-     * 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';
-    }>;
+export type SegmentBatchCreateRequest = {
+    segments: Array<SegmentCreateRequest>;
 };
 export type UserQuotaResponse = {
     /**
@@ -1430,9 +1530,43 @@ export type ReportTargetMedia = {
      */
     type: 'MEDIA';
     /**
-     * Media ID this report targets
+     * Public ID of the media this report targets
      */
-    mediaId: number;
+    mediaId: string;
+};
+export type ReportTargetSegmentInput = {
+    /**
+     * Report target type
+     */
+    type: 'SEGMENT';
+    /**
+     * Public ID of the media this report targets
+     */
+    mediaId: string;
+    /**
+     * Episode number containing the segment
+     */
+    episodeNumber?: number;
+    /**
+     * Segment public ID or UUID
+     */
+    segmentId: string;
+};
+export type UserReportTarget = ({
+    type: 'MEDIA';
+} & ReportTargetMedia) | ({
+    type: 'SEGMENT';
+} & ReportTargetSegmentInput);
+export type CreateReportRequest = {
+    target: UserReportTarget;
+    /**
+     * Reason for the report
+     */
+    reason: 'WRONG_TRANSLATION' | 'WRONG_TIMING' | 'WRONG_AUDIO' | 'WRONG_JAPANESE_TEXT' | 'LOW_QUALITY_AUDIO' | 'NSFW_NOT_TAGGED' | 'DUPLICATE_SEGMENT' | 'WRONG_TITLE' | 'DUPLICATE_MEDIA' | 'WRONG_EPISODE_NUMBER' | 'IMAGE_ISSUE' | 'MISSING_EPISODES' | 'INAPPROPRIATE_CONTENT' | 'OTHER';
+    /**
+     * Optional description with additional details
+     */
+    description?: string;
 };
 export type ReportTargetEpisode = {
     /**
@@ -1440,9 +1574,9 @@ export type ReportTargetEpisode = {
      */
     type: 'EPISODE';
     /**
-     * Media ID this report targets
+     * Public ID of the media this report targets
      */
-    mediaId: number;
+    mediaId: string;
     /**
      * Episode number this report targets
      */
@@ -1454,17 +1588,17 @@ export type ReportTargetSegment = {
      */
     type: 'SEGMENT';
     /**
-     * Media ID this report targets
+     * Public ID of the media this report targets
      */
-    mediaId: number;
+    mediaId: string;
     /**
      * Episode number containing the segment
      */
     episodeNumber?: number;
     /**
-     * Segment UUID this report targets
+     * Segment public ID or UUID
      */
-    segmentUuid: string;
+    segmentId: string;
 };
 export type ReportTarget = ({
     type: 'MEDIA';
@@ -1484,21 +1618,21 @@ 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
      */
-    reason: 'WRONG_TRANSLATION' | 'WRONG_TIMING' | 'WRONG_AUDIO' | 'NSFW_NOT_TAGGED' | 'DUPLICATE_SEGMENT' | 'WRONG_METADATA' | 'MISSING_EPISODES' | 'WRONG_COVER_IMAGE' | 'INAPPROPRIATE_CONTENT' | 'OTHER' | 'LOW_SEGMENT_MEDIA' | 'EMPTY_EPISODES' | 'MISSING_EPISODES_AUTO' | 'BAD_SEGMENT_RATIO' | 'MEDIA_WITH_NO_EPISODES' | 'MISSING_TRANSLATIONS' | 'DB_ES_SYNC_ISSUES' | 'HIGH_REPORT_DENSITY';
+    reason: 'WRONG_TRANSLATION' | 'WRONG_TIMING' | 'WRONG_AUDIO' | 'WRONG_JAPANESE_TEXT' | 'LOW_QUALITY_AUDIO' | 'NSFW_NOT_TAGGED' | 'DUPLICATE_SEGMENT' | 'WRONG_METADATA' | 'MISSING_EPISODES' | 'WRONG_COVER_IMAGE' | 'WRONG_TITLE' | 'DUPLICATE_MEDIA' | 'WRONG_EPISODE_NUMBER' | 'IMAGE_ISSUE' | 'INAPPROPRIATE_CONTENT' | 'OTHER' | 'LOW_SEGMENT_MEDIA' | 'EMPTY_EPISODES' | 'MISSING_EPISODES_AUTO' | 'BAD_SEGMENT_RATIO' | 'MEDIA_WITH_NO_EPISODES' | 'MISSING_TRANSLATIONS' | 'DB_ES_SYNC_ISSUES' | 'HIGH_REPORT_DENSITY';
     /**
      * Optional description with additional details
      */
-    description?: string;
+    description: string;
     /**
      * Check-specific metrics (AUTO reports) or null (USER reports)
      */
-    data?: {
+    data: {
         [key: string]: unknown;
     };
     /**
@@ -1508,11 +1642,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
      */
@@ -1520,35 +1654,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
      */
@@ -1595,17 +1703,26 @@ export type UserPreferences = {
 /**
  * Type of user activity
  */
-export type ActivityType = 'SEARCH' | 'ANKI_EXPORT' | 'SEGMENT_PLAY' | 'LIST_ADD_SEGMENT';
+export type ActivityType = 'SEARCH' | 'ANKI_EXPORT' | 'SEGMENT_PLAY' | 'SHARE';
 export type UserActivity = {
     id: number;
     activityType: ActivityType;
-    segmentUuid?: string;
-    mediaId?: number;
-    searchQuery?: string;
-    animeName?: string;
-    japaneseText?: string;
+    segmentId: number;
+    mediaId: number;
+    searchQuery: string;
+    mediaName: string;
+    japaneseText: string;
     createdAt: string;
 };
+/**
+ * Activity counts for a single day, broken down by type. Only types with at least 1 event are present.
+ */
+export type HeatmapDayCounts = {
+    SEARCH?: number;
+    SEGMENT_PLAY?: number;
+    ANKI_EXPORT?: number;
+    SHARE?: number;
+};
 /**
  * User segment collection
  */
@@ -1614,14 +1731,18 @@ export type Collection = {
      * Collection ID
      */
     id: number;
+    /**
+     * Public identifier for the collection
+     */
+    publicId: string;
     /**
      * Name of the collection
      */
     name: string;
     /**
-     * User ID who owns the collection
+     * Type of the collection
      */
-    userId: number;
+    type: 'USER' | 'ANKI_EXPORT';
     /**
      * Visibility of the collection
      */
@@ -1629,21 +1750,21 @@ 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 & {
     /**
-     * Segment UUIDs in saved order
+     * Segment IDs in saved order
      */
-    segmentUuids: Array<string>;
+    segmentIds: Array<number>;
 };
 /**
  * User data export payload (identifier-oriented references)
@@ -1662,32 +1783,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
@@ -1714,14 +1835,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
      */
@@ -1729,18 +1858,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;
         };
     };
@@ -1748,7 +1877,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
@@ -1778,44 +1907,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 & {
@@ -1830,7 +1959,7 @@ export type AdminReport = Report & {
 };
 export type AdminReportListResponse = {
     reports: Array<AdminReport>;
-    pagination: CursorPagination;
+    pagination: OpaqueCursorPagination;
 };
 export type UpdateReportRequest = {
     /**
@@ -1842,41 +1971,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;
     /**
@@ -1884,11 +1985,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';
     /**
@@ -1898,40 +1999,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
      */
@@ -1951,32 +2080,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;
@@ -1989,7 +2092,7 @@ export type SearchErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2025,7 +2128,7 @@ export type GetSearchStatsErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2061,7 +2164,7 @@ export type SearchWordsErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2092,11 +2195,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
          */
@@ -2106,25 +2209,164 @@ 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>;
+    };
+    url: '/v1/media';
+};
+export type ListMediaErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized (API key)
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type ListMediaError = ListMediaErrors[keyof ListMediaErrors];
+export type ListMediaResponses = {
+    /**
+     * OK
+     */
+    200: MediaListResponse;
+};
+export type ListMediaResponse = ListMediaResponses[keyof ListMediaResponses];
+export type CreateMediaData = {
+    body: MediaCreateRequest;
+    path?: never;
+    query?: never;
+    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 or publicId
+         */
+        uuid: string;
+    };
+    query?: {
+        /**
+         * Additional internal fields to include in the response
          */
-        include?: Array<MediaIncludeExpansion>;
+        include?: Array<'ratingAnalysis' | 'posAnalysis' | 'hashedId' | 'storageBasePath' | 'storage'>;
     };
-    url: '/v1/media';
+    url: '/v1/media/segments/{uuid}';
 };
-export type ListMediaErrors = {
+export type GetSegmentByUuidErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key or session)
      */
     401: Error401;
     /**
      * Forbidden
      */
     403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
     /**
      * Too Many Requests
      */
@@ -2134,27 +2376,32 @@ export type ListMediaErrors = {
      */
     500: Error500;
 };
-export type ListMediaError = ListMediaErrors[keyof ListMediaErrors];
-export type ListMediaResponses = {
+export type GetSegmentByUuidError = GetSegmentByUuidErrors[keyof GetSegmentByUuidErrors];
+export type GetSegmentByUuidResponses = {
     /**
-     * OK
+     * Single segment response with internal fields
      */
-    200: MediaListResponse;
+    200: SegmentInternal;
 };
-export type ListMediaResponse = ListMediaResponses[keyof ListMediaResponses];
-export type CreateMediaData = {
-    body: MediaCreateRequest;
-    path?: never;
+export type GetSegmentByUuidResponse = GetSegmentByUuidResponses[keyof GetSegmentByUuidResponses];
+export type UpdateSegmentByUuidData = {
+    body: SegmentUpdateRequest;
+    path: {
+        /**
+         * Segment UUID or publicId
+         */
+        uuid: string;
+    };
     query?: never;
-    url: '/v1/media';
+    url: '/v1/media/segments/{uuid}';
 };
-export type CreateMediaErrors = {
+export type UpdateSegmentByUuidErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key or session)
      */
     401: Error401;
     /**
@@ -2162,9 +2409,9 @@ export type CreateMediaErrors = {
      */
     403: Error403;
     /**
-     * Conflict
+     * Not Found
      */
-    409: Error409;
+    404: Error404;
     /**
      * Too Many Requests
      */
@@ -2174,46 +2421,51 @@ export type CreateMediaErrors = {
      */
     500: Error500;
 };
-export type CreateMediaError = CreateMediaErrors[keyof CreateMediaErrors];
-export type CreateMediaResponses = {
+export type UpdateSegmentByUuidError = UpdateSegmentByUuidErrors[keyof UpdateSegmentByUuidErrors];
+export type UpdateSegmentByUuidResponses = {
     /**
-     * Created
+     * Single segment response with internal fields
      */
-    201: Media;
+    200: SegmentInternal;
 };
-export type CreateMediaResponse = CreateMediaResponses[keyof CreateMediaResponses];
-export type AutocompleteMediaData = {
+export type UpdateSegmentByUuidResponse = UpdateSegmentByUuidResponses[keyof UpdateSegmentByUuidResponses];
+export type GetSegmentContextData = {
     body?: never;
-    path?: never;
-    query: {
+    path: {
         /**
-         * Search term to match against media names (English, Japanese, romaji)
+         * Segment UUID or publicId
          */
-        query: string;
+        uuid: string;
+    };
+    query?: {
         /**
-         * Maximum number of results to return
+         * Number of segments to return before and after the target
          */
-        limit?: number;
+        take?: number;
         /**
-         * Filter by media category
+         * Content ratings to include (omit for all ratings)
          */
-        category?: 'ANIME' | 'JDRAMA';
+        contentRating?: Array<ContentRating>;
     };
-    url: '/v1/media/autocomplete';
+    url: '/v1/media/segments/{uuid}/context';
 };
-export type AutocompleteMediaErrors = {
+export type GetSegmentContextErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key or session)
      */
     401: Error401;
     /**
      * Forbidden
      */
     403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
     /**
      * Too Many Requests
      */
@@ -2223,32 +2475,32 @@ export type AutocompleteMediaErrors = {
      */
     500: Error500;
 };
-export type AutocompleteMediaError = AutocompleteMediaErrors[keyof AutocompleteMediaErrors];
-export type AutocompleteMediaResponses = {
+export type GetSegmentContextError = GetSegmentContextErrors[keyof GetSegmentContextErrors];
+export type GetSegmentContextResponses = {
     /**
      * OK
      */
-    200: MediaAutocompleteResponse;
+    200: SegmentContextResponse;
 };
-export type AutocompleteMediaResponse = AutocompleteMediaResponses[keyof AutocompleteMediaResponses];
-export type DeleteMediaData = {
+export type GetSegmentContextResponse = GetSegmentContextResponses[keyof GetSegmentContextResponses];
+export type ListSegmentRevisionsData = {
     body?: never;
     path: {
         /**
-         * Media ID
+         * Segment UUID or publicId
          */
-        id: number;
+        uuid: string;
     };
     query?: never;
-    url: '/v1/media/{id}';
+    url: '/v1/media/segments/{uuid}/revisions';
 };
-export type DeleteMediaErrors = {
+export type ListSegmentRevisionsErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key or session)
      */
     401: Error401;
     /**
@@ -2268,47 +2520,48 @@ export type DeleteMediaErrors = {
      */
     500: Error500;
 };
-export type DeleteMediaError = DeleteMediaErrors[keyof DeleteMediaErrors];
-export type DeleteMediaResponses = {
+export type ListSegmentRevisionsError = ListSegmentRevisionsErrors[keyof ListSegmentRevisionsErrors];
+export type ListSegmentRevisionsResponses = {
     /**
-     * No Content
+     * List of segment revisions
      */
-    204: void;
+    200: {
+        revisions: Array<SegmentRevision>;
+    };
 };
-export type DeleteMediaResponse = DeleteMediaResponses[keyof DeleteMediaResponses];
-export type GetMediaData = {
+export type ListSegmentRevisionsResponse = ListSegmentRevisionsResponses[keyof ListSegmentRevisionsResponses];
+export type ListSeriesData = {
     body?: never;
-    path: {
+    path?: never;
+    query?: {
         /**
-         * Media ID
+         * Number of results per page
          */
-        id: number;
-    };
-    query?: {
+        take?: number;
         /**
-         * Resources to expand in the media response (`media.characters` implies `media`)
+         * Opaque pagination cursor token
          */
-        include?: Array<MediaIncludeExpansion>;
+        cursor?: string;
+        /**
+         * Case-insensitive search across English, Japanese, and Romaji names
+         */
+        query?: string;
     };
-    url: '/v1/media/{id}';
+    url: '/v1/media/series';
 };
-export type GetMediaErrors = {
+export type ListSeriesErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
      * Forbidden
      */
     403: Error403;
-    /**
-     * Not Found
-     */
-    404: Error404;
     /**
      * Too Many Requests
      */
@@ -2318,42 +2571,46 @@ export type GetMediaErrors = {
      */
     500: Error500;
 };
-export type GetMediaError = GetMediaErrors[keyof GetMediaErrors];
-export type GetMediaResponses = {
+export type ListSeriesError = ListSeriesErrors[keyof ListSeriesErrors];
+export type ListSeriesResponses = {
     /**
      * OK
      */
-    200: Media;
+    200: SeriesListResponse;
 };
-export type GetMediaResponse = GetMediaResponses[keyof GetMediaResponses];
-export type UpdateMediaData = {
-    body: MediaUpdateRequest;
-    path: {
+export type ListSeriesResponse = ListSeriesResponses[keyof ListSeriesResponses];
+export type CreateSeriesData = {
+    body: {
         /**
-         * Media ID
+         * Japanese name of the series
          */
-        id: number;
+        nameJa: string;
+        /**
+         * Romaji name of the series
+         */
+        nameRomaji: string;
+        /**
+         * English name of the series
+         */
+        nameEn: string;
     };
+    path?: never;
     query?: never;
-    url: '/v1/media/{id}';
+    url: '/v1/media/series';
 };
-export type UpdateMediaErrors = {
+export type CreateSeriesErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
      * Forbidden
      */
     403: Error403;
-    /**
-     * Not Found
-     */
-    404: Error404;
     /**
      * Too Many Requests
      */
@@ -2363,41 +2620,32 @@ export type UpdateMediaErrors = {
      */
     500: Error500;
 };
-export type UpdateMediaError = UpdateMediaErrors[keyof UpdateMediaErrors];
-export type UpdateMediaResponses = {
+export type CreateSeriesError = CreateSeriesErrors[keyof CreateSeriesErrors];
+export type CreateSeriesResponses = {
     /**
-     * OK
+     * Created
      */
-    200: Media;
+    201: Series;
 };
-export type UpdateMediaResponse = UpdateMediaResponses[keyof UpdateMediaResponses];
-export type ListEpisodesData = {
+export type CreateSeriesResponse = CreateSeriesResponses[keyof CreateSeriesResponses];
+export type DeleteSeriesData = {
     body?: never;
     path: {
         /**
-         * ID of the media
-         */
-        mediaId: number;
-    };
-    query?: {
-        /**
-         * Maximum number of episodes to return
-         */
-        limit?: number;
-        /**
-         * Episode number to start from (for pagination)
+         * Series public ID
          */
-        cursor?: number;
+        id: string;
     };
-    url: '/v1/media/{mediaId}/episodes';
+    query?: never;
+    url: '/v1/media/series/{id}';
 };
-export type ListEpisodesErrors = {
+export type DeleteSeriesErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2417,32 +2665,37 @@ export type ListEpisodesErrors = {
      */
     500: Error500;
 };
-export type ListEpisodesError = ListEpisodesErrors[keyof ListEpisodesErrors];
-export type ListEpisodesResponses = {
+export type DeleteSeriesError = DeleteSeriesErrors[keyof DeleteSeriesErrors];
+export type DeleteSeriesResponses = {
     /**
-     * Paginated list of episodes
+     * No Content
      */
-    200: EpisodeListResponse;
+    204: void;
 };
-export type ListEpisodesResponse = ListEpisodesResponses[keyof ListEpisodesResponses];
-export type CreateEpisodeData = {
-    body: EpisodeCreateRequest;
+export type DeleteSeriesResponse = DeleteSeriesResponses[keyof DeleteSeriesResponses];
+export type GetSeriesData = {
+    body?: never;
     path: {
         /**
-         * ID of the media
+         * Series public ID
          */
-        mediaId: number;
+        id: string;
     };
-    query?: never;
-    url: '/v1/media/{mediaId}/episodes';
+    query?: {
+        /**
+         * Resources to expand in the series response
+         */
+        include?: Array<MediaIncludeExpansion>;
+    };
+    url: '/v1/media/series/{id}';
 };
-export type CreateEpisodeErrors = {
+export type GetSeriesErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2453,10 +2706,6 @@ export type CreateEpisodeErrors = {
      * Not Found
      */
     404: Error404;
-    /**
-     * Conflict
-     */
-    409: Error409;
     /**
      * Too Many Requests
      */
@@ -2466,36 +2715,45 @@ export type CreateEpisodeErrors = {
      */
     500: Error500;
 };
-export type CreateEpisodeError = CreateEpisodeErrors[keyof CreateEpisodeErrors];
-export type CreateEpisodeResponses = {
+export type GetSeriesError = GetSeriesErrors[keyof GetSeriesErrors];
+export type GetSeriesResponses = {
     /**
-     * Single episode response
+     * OK
      */
-    201: Episode;
+    200: SeriesWithMedia;
 };
-export type CreateEpisodeResponse = CreateEpisodeResponses[keyof CreateEpisodeResponses];
-export type DeleteEpisodeData = {
-    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 public ID
+         */
+        id: string;
     };
     query?: never;
-    url: '/v1/media/{mediaId}/episodes/{episodeNumber}';
+    url: '/v1/media/series/{id}';
 };
-export type DeleteEpisodeErrors = {
+export type UpdateSeriesErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2515,36 +2773,41 @@ export type DeleteEpisodeErrors = {
      */
     500: Error500;
 };
-export type DeleteEpisodeError = DeleteEpisodeErrors[keyof DeleteEpisodeErrors];
-export type DeleteEpisodeResponses = {
+export type UpdateSeriesError = UpdateSeriesErrors[keyof UpdateSeriesErrors];
+export type UpdateSeriesResponses = {
     /**
-     * Episode successfully deleted
+     * OK
      */
-    204: void;
+    200: Series;
 };
-export type DeleteEpisodeResponse = DeleteEpisodeResponses[keyof DeleteEpisodeResponses];
-export type GetEpisodeData = {
-    body?: never;
-    path: {
+export type UpdateSeriesResponse = UpdateSeriesResponses[keyof UpdateSeriesResponses];
+export type AddMediaToSeriesData = {
+    body: {
         /**
-         * ID of the media
+         * Media public ID to add
          */
-        mediaId: number;
+        mediaId: string;
         /**
-         * Episode number
+         * Position in the series (1-indexed)
+         */
+        position: number;
+    };
+    path: {
+        /**
+         * Series public ID
          */
-        episodeNumber: number;
+        id: string;
     };
     query?: never;
-    url: '/v1/media/{mediaId}/episodes/{episodeNumber}';
+    url: '/v1/media/series/{id}/media';
 };
-export type GetEpisodeErrors = {
+export type AddMediaToSeriesErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2564,36 +2827,36 @@ export type GetEpisodeErrors = {
      */
     500: Error500;
 };
-export type GetEpisodeError = GetEpisodeErrors[keyof GetEpisodeErrors];
-export type GetEpisodeResponses = {
+export type AddMediaToSeriesError = AddMediaToSeriesErrors[keyof AddMediaToSeriesErrors];
+export type AddMediaToSeriesResponses = {
     /**
-     * Single episode response
+     * No Content
      */
-    200: Episode;
+    204: void;
 };
-export type GetEpisodeResponse = GetEpisodeResponses[keyof GetEpisodeResponses];
-export type UpdateEpisodeData = {
-    body: EpisodeUpdateRequest;
+export type AddMediaToSeriesResponse = AddMediaToSeriesResponses[keyof AddMediaToSeriesResponses];
+export type RemoveMediaFromSeriesData = {
+    body?: never;
     path: {
         /**
-         * ID of the media
+         * Series public ID
          */
-        mediaId: number;
+        id: string;
         /**
-         * Episode number
+         * Media public ID
          */
-        episodeNumber: number;
+        mediaId: string;
     };
     query?: never;
-    url: '/v1/media/{mediaId}/episodes/{episodeNumber}';
+    url: '/v1/media/series/{id}/media/{mediaId}';
 };
-export type UpdateEpisodeErrors = {
+export type RemoveMediaFromSeriesErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2613,45 +2876,41 @@ export type UpdateEpisodeErrors = {
      */
     500: Error500;
 };
-export type UpdateEpisodeError = UpdateEpisodeErrors[keyof UpdateEpisodeErrors];
-export type UpdateEpisodeResponses = {
+export type RemoveMediaFromSeriesError = RemoveMediaFromSeriesErrors[keyof RemoveMediaFromSeriesErrors];
+export type RemoveMediaFromSeriesResponses = {
     /**
-     * Single episode response
+     * No Content
      */
-    200: Episode;
+    204: void;
 };
-export type UpdateEpisodeResponse = UpdateEpisodeResponses[keyof UpdateEpisodeResponses];
-export type ListSegmentsData = {
-    body?: never;
-    path: {
-        /**
-         * ID of the media
-         */
-        mediaId: number;
+export type RemoveMediaFromSeriesResponse = RemoveMediaFromSeriesResponses[keyof RemoveMediaFromSeriesResponses];
+export type UpdateSeriesMediaData = {
+    body: {
         /**
-         * Episode number
+         * New position in the series (1-indexed)
          */
-        episodeNumber: number;
+        position: number;
     };
-    query?: {
+    path: {
         /**
-         * Maximum number of segments to return
+         * Series public ID
          */
-        limit?: number;
+        id: string;
         /**
-         * Segment ID to start from (for pagination)
+         * Media public ID
          */
-        cursor?: number;
+        mediaId: string;
     };
-    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments';
+    query?: never;
+    url: '/v1/media/series/{id}/media/{mediaId}';
 };
-export type ListSegmentsErrors = {
+export type UpdateSeriesMediaErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2671,42 +2930,32 @@ export type ListSegmentsErrors = {
      */
     500: Error500;
 };
-export type ListSegmentsError = ListSegmentsErrors[keyof ListSegmentsErrors];
-export type ListSegmentsResponses = {
+export type UpdateSeriesMediaError = UpdateSeriesMediaErrors[keyof UpdateSeriesMediaErrors];
+export type UpdateSeriesMediaResponses = {
     /**
-     * Paginated segment list response
+     * No Content
      */
-    200: {
-        /**
-         * Array of segment objects
-         */
-        segments: Array<Segment>;
-        pagination: CursorPagination;
-    };
+    204: void;
 };
-export type ListSegmentsResponse = ListSegmentsResponses[keyof ListSegmentsResponses];
-export type CreateSegmentData = {
-    body: SegmentCreateRequest;
+export type UpdateSeriesMediaResponse = UpdateSeriesMediaResponses[keyof UpdateSeriesMediaResponses];
+export type GetCharacterData = {
+    body?: never;
     path: {
         /**
-         * ID of the media
-         */
-        mediaId: number;
-        /**
-         * Episode number
+         * Character ID
          */
-        episodeNumber: number;
+        id: number;
     };
     query?: never;
-    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments';
+    url: '/v1/media/characters/{id}';
 };
-export type CreateSegmentErrors = {
+export type GetCharacterErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2717,10 +2966,6 @@ export type CreateSegmentErrors = {
      * Not Found
      */
     404: Error404;
-    /**
-     * Conflict
-     */
-    409: Error409;
     /**
      * Too Many Requests
      */
@@ -2730,40 +2975,32 @@ export type CreateSegmentErrors = {
      */
     500: Error500;
 };
-export type CreateSegmentError = CreateSegmentErrors[keyof CreateSegmentErrors];
-export type CreateSegmentResponses = {
+export type GetCharacterError = GetCharacterErrors[keyof GetCharacterErrors];
+export type GetCharacterResponses = {
     /**
-     * Single segment response with internal fields
+     * OK
      */
-    201: SegmentInternal;
+    200: CharacterWithMedia;
 };
-export type CreateSegmentResponse = CreateSegmentResponses[keyof CreateSegmentResponses];
-export type DeleteSegmentData = {
+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 DeleteSegmentErrors = {
+export type GetSeiyuuErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2783,40 +3020,32 @@ export type DeleteSegmentErrors = {
      */
     500: Error500;
 };
-export type DeleteSegmentError = DeleteSegmentErrors[keyof DeleteSegmentErrors];
-export type DeleteSegmentResponses = {
+export type GetSeiyuuError = GetSeiyuuErrors[keyof GetSeiyuuErrors];
+export type GetSeiyuuResponses = {
     /**
-     * Segment successfully deleted
+     * OK
      */
-    204: void;
+    200: SeiyuuWithRoles;
 };
-export type DeleteSegmentResponse = DeleteSegmentResponses[keyof DeleteSegmentResponses];
-export type GetSegmentData = {
+export type GetSeiyuuResponse = GetSeiyuuResponses[keyof GetSeiyuuResponses];
+export type DeleteMediaData = {
     body?: never;
     path: {
         /**
-         * ID of the media
+         * Media public ID
          */
-        mediaId: number;
-        /**
-         * Episode number
-         */
-        episodeNumber: number;
-        /**
-         * Segment ID
-         */
-        id: number;
+        id: string;
     };
     query?: never;
-    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments/{id}';
+    url: '/v1/media/{id}';
 };
-export type GetSegmentErrors = {
+export type DeleteMediaErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2836,40 +3065,37 @@ export type GetSegmentErrors = {
      */
     500: Error500;
 };
-export type GetSegmentError = GetSegmentErrors[keyof GetSegmentErrors];
-export type GetSegmentResponses = {
+export type DeleteMediaError = DeleteMediaErrors[keyof DeleteMediaErrors];
+export type DeleteMediaResponses = {
     /**
-     * Single segment response
+     * No Content
      */
-    200: Segment;
+    204: void;
 };
-export type GetSegmentResponse = GetSegmentResponses[keyof GetSegmentResponses];
-export type UpdateSegmentData = {
-    body: SegmentUpdateRequest;
+export type DeleteMediaResponse = DeleteMediaResponses[keyof DeleteMediaResponses];
+export type GetMediaData = {
+    body?: never;
     path: {
         /**
-         * ID of the media
-         */
-        mediaId: number;
-        /**
-         * Episode number
+         * Media public ID
          */
-        episodeNumber: number;
+        id: string;
+    };
+    query?: {
         /**
-         * Segment ID
+         * Resources to expand in the media response
          */
-        id: number;
+        include?: Array<MediaIncludeExpansion>;
     };
-    query?: never;
-    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments/{id}';
+    url: '/v1/media/{id}';
 };
-export type UpdateSegmentErrors = {
+export type GetMediaErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2889,32 +3115,32 @@ export type UpdateSegmentErrors = {
      */
     500: Error500;
 };
-export type UpdateSegmentError = UpdateSegmentErrors[keyof UpdateSegmentErrors];
-export type UpdateSegmentResponses = {
+export type GetMediaError = GetMediaErrors[keyof GetMediaErrors];
+export type GetMediaResponses = {
     /**
-     * Single segment response with internal fields
+     * OK
      */
-    200: SegmentInternal;
+    200: Media;
 };
-export type UpdateSegmentResponse = UpdateSegmentResponses[keyof UpdateSegmentResponses];
-export type GetSegmentByUuidData = {
-    body?: never;
+export type GetMediaResponse = GetMediaResponses[keyof GetMediaResponses];
+export type UpdateMediaData = {
+    body: MediaUpdateRequest;
     path: {
         /**
-         * Segment UUID
+         * Media public ID
          */
-        uuid: string;
+        id: string;
     };
     query?: never;
-    url: '/v1/media/segments/{uuid}';
+    url: '/v1/media/{id}';
 };
-export type GetSegmentByUuidErrors = {
+export type UpdateMediaErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2934,42 +3160,41 @@ export type GetSegmentByUuidErrors = {
      */
     500: Error500;
 };
-export type GetSegmentByUuidError = GetSegmentByUuidErrors[keyof GetSegmentByUuidErrors];
-export type GetSegmentByUuidResponses = {
-    200: Segment;
+export type UpdateMediaError = UpdateMediaErrors[keyof UpdateMediaErrors];
+export type UpdateMediaResponses = {
+    /**
+     * OK
+     */
+    200: Media;
 };
-export type GetSegmentByUuidResponse = GetSegmentByUuidResponses[keyof GetSegmentByUuidResponses];
-export type GetSegmentContextData = {
+export type UpdateMediaResponse = UpdateMediaResponses[keyof UpdateMediaResponses];
+export type ListEpisodesData = {
     body?: never;
     path: {
         /**
-         * Segment UUID
+         * Public ID of the media
          */
-        uuid: string;
+        mediaId: string;
     };
     query?: {
         /**
-         * Number of segments to return before and after the target
-         */
-        limit?: number;
-        /**
-         * Content ratings to include (omit for all ratings)
+         * Maximum number of episodes to return
          */
-        contentRating?: Array<ContentRating>;
+        take?: number;
         /**
-         * Resources to expand in the response includes block
+         * Opaque pagination cursor token
          */
-        include?: Array<IncludeExpansion>;
+        cursor?: string;
     };
-    url: '/v1/media/segments/{uuid}/context';
+    url: '/v1/media/{mediaId}/episodes';
 };
-export type GetSegmentContextErrors = {
+export type ListEpisodesErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -2989,46 +3214,46 @@ export type GetSegmentContextErrors = {
      */
     500: Error500;
 };
-export type GetSegmentContextError = GetSegmentContextErrors[keyof GetSegmentContextErrors];
-export type GetSegmentContextResponses = {
+export type ListEpisodesError = ListEpisodesErrors[keyof ListEpisodesErrors];
+export type ListEpisodesResponses = {
     /**
-     * OK
+     * Paginated list of episodes
      */
-    200: SegmentContextResponse;
+    200: EpisodeListResponse;
 };
-export type GetSegmentContextResponse = GetSegmentContextResponses[keyof GetSegmentContextResponses];
-export type ListSeriesData = {
-    body?: never;
-    path?: never;
-    query?: {
-        /**
-         * Number of results per page
-         */
-        limit?: number;
-        /**
-         * Pagination cursor offset
-         */
-        cursor?: number;
+export type ListEpisodesResponse = ListEpisodesResponses[keyof ListEpisodesResponses];
+export type CreateEpisodeData = {
+    body: EpisodeCreateRequest;
+    path: {
         /**
-         * Case-insensitive search across English, Japanese, and Romaji names
+         * Public ID of the media
          */
-        query?: string;
+        mediaId: string;
     };
-    url: '/v1/media/series';
+    query?: never;
+    url: '/v1/media/{mediaId}/episodes';
 };
-export type ListSeriesErrors = {
+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
      */
@@ -3037,47 +3262,47 @@ export type ListSeriesErrors = {
      * Internal Server Error
      */
     500: Error500;
-};
-export type ListSeriesError = ListSeriesErrors[keyof ListSeriesErrors];
-export type ListSeriesResponses = {
+};
+export type CreateEpisodeError = CreateEpisodeErrors[keyof CreateEpisodeErrors];
+export type CreateEpisodeResponses = {
     /**
-     * OK
+     * Single episode response
      */
-    200: SeriesListResponse;
+    201: Episode;
 };
-export type ListSeriesResponse = ListSeriesResponses[keyof ListSeriesResponses];
-export type CreateSeriesData = {
-    body: {
-        /**
-         * Japanese name of the series
-         */
-        nameJa: string;
+export type CreateEpisodeResponse = CreateEpisodeResponses[keyof CreateEpisodeResponses];
+export type DeleteEpisodeData = {
+    body?: never;
+    path: {
         /**
-         * Romaji name of the series
+         * Public ID of the media
          */
-        nameRomaji: string;
+        mediaId: string;
         /**
-         * English name of the series
+         * Episode number
          */
-        nameEn: string;
+        episodeNumber: number;
     };
-    path?: never;
     query?: never;
-    url: '/v1/media/series';
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}';
 };
-export type CreateSeriesErrors = {
+export type DeleteEpisodeErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
      * Forbidden
      */
     403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
     /**
      * Too Many Requests
      */
@@ -3087,32 +3312,36 @@ export type CreateSeriesErrors = {
      */
     500: Error500;
 };
-export type CreateSeriesError = CreateSeriesErrors[keyof CreateSeriesErrors];
-export type CreateSeriesResponses = {
+export type DeleteEpisodeError = DeleteEpisodeErrors[keyof DeleteEpisodeErrors];
+export type DeleteEpisodeResponses = {
     /**
-     * Created
+     * Episode successfully deleted
      */
-    201: Series;
+    204: void;
 };
-export type CreateSeriesResponse = CreateSeriesResponses[keyof CreateSeriesResponses];
-export type DeleteSeriesData = {
+export type DeleteEpisodeResponse = DeleteEpisodeResponses[keyof DeleteEpisodeResponses];
+export type GetEpisodeData = {
     body?: never;
     path: {
         /**
-         * Series ID
+         * Public ID of the media
          */
-        id: number;
+        mediaId: string;
+        /**
+         * Episode number
+         */
+        episodeNumber: number;
     };
     query?: never;
-    url: '/v1/media/series/{id}';
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}';
 };
-export type DeleteSeriesErrors = {
+export type GetEpisodeErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -3132,37 +3361,36 @@ export type DeleteSeriesErrors = {
      */
     500: Error500;
 };
-export type DeleteSeriesError = DeleteSeriesErrors[keyof DeleteSeriesErrors];
-export type DeleteSeriesResponses = {
+export type GetEpisodeError = GetEpisodeErrors[keyof GetEpisodeErrors];
+export type GetEpisodeResponses = {
     /**
-     * No Content
+     * Single episode response
      */
-    204: void;
+    200: Episode;
 };
-export type DeleteSeriesResponse = DeleteSeriesResponses[keyof DeleteSeriesResponses];
-export type GetSeriesData = {
-    body?: never;
+export type GetEpisodeResponse = GetEpisodeResponses[keyof GetEpisodeResponses];
+export type UpdateEpisodeData = {
+    body: EpisodeUpdateRequest;
     path: {
         /**
-         * Series ID
+         * Public ID of the media
          */
-        id: number;
-    };
-    query?: {
+        mediaId: string;
         /**
-         * 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 UpdateEpisodeErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -3182,45 +3410,45 @@ export type GetSeriesErrors = {
      */
     500: Error500;
 };
-export type GetSeriesError = GetSeriesErrors[keyof GetSeriesErrors];
-export type GetSeriesResponses = {
+export type UpdateEpisodeError = UpdateEpisodeErrors[keyof UpdateEpisodeErrors];
+export type UpdateEpisodeResponses = {
     /**
-     * OK
+     * Single episode response
      */
-    200: SeriesWithMedia;
+    200: Episode;
 };
-export type GetSeriesResponse = GetSeriesResponses[keyof GetSeriesResponses];
-export type UpdateSeriesData = {
-    body: {
+export type UpdateEpisodeResponse = UpdateEpisodeResponses[keyof UpdateEpisodeResponses];
+export type ListSegmentsData = {
+    body?: never;
+    path: {
         /**
-         * Updated Japanese name
+         * Public ID of the media
          */
-        nameJa?: string;
+        mediaId: string;
         /**
-         * Updated Romaji name
+         * Episode number
          */
-        nameRomaji?: string;
+        episodeNumber: number;
+    };
+    query?: {
         /**
-         * Updated English name
+         * Maximum number of segments to return
          */
-        nameEn?: string;
-    };
-    path: {
+        take?: number;
         /**
-         * Series ID
+         * Opaque pagination cursor token
          */
-        id: number;
+        cursor?: string;
     };
-    query?: never;
-    url: '/v1/media/series/{id}';
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments';
 };
-export type UpdateSeriesErrors = {
+export type ListSegmentsErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -3240,41 +3468,42 @@ export type UpdateSeriesErrors = {
      */
     500: Error500;
 };
-export type UpdateSeriesError = UpdateSeriesErrors[keyof UpdateSeriesErrors];
-export type UpdateSeriesResponses = {
+export type ListSegmentsError = ListSegmentsErrors[keyof ListSegmentsErrors];
+export type ListSegmentsResponses = {
     /**
-     * OK
+     * Paginated segment list response
      */
-    200: Series;
-};
-export type UpdateSeriesResponse = UpdateSeriesResponses[keyof UpdateSeriesResponses];
-export type AddMediaToSeriesData = {
-    body: {
-        /**
-         * Media ID to add
-         */
-        mediaId: number;
+    200: {
         /**
-         * Position in the series (1-indexed)
+         * Array of segment objects
          */
-        position: number;
+        segments: Array<Segment>;
+        pagination: OpaqueCursorPagination;
     };
+};
+export type ListSegmentsResponse = ListSegmentsResponses[keyof ListSegmentsResponses];
+export type CreateSegmentData = {
+    body: SegmentCreateRequest;
     path: {
         /**
-         * Series ID
+         * Public ID of the media
          */
-        id: number;
+        mediaId: string;
+        /**
+         * Episode number
+         */
+        episodeNumber: number;
     };
     query?: never;
-    url: '/v1/media/series/{id}/media';
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments';
 };
-export type AddMediaToSeriesErrors = {
+export type CreateSegmentErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -3285,6 +3514,10 @@ export type AddMediaToSeriesErrors = {
      * Not Found
      */
     404: Error404;
+    /**
+     * Conflict
+     */
+    409: Error409;
     /**
      * Too Many Requests
      */
@@ -3294,36 +3527,36 @@ export type AddMediaToSeriesErrors = {
      */
     500: Error500;
 };
-export type AddMediaToSeriesError = AddMediaToSeriesErrors[keyof AddMediaToSeriesErrors];
-export type AddMediaToSeriesResponses = {
+export type CreateSegmentError = CreateSegmentErrors[keyof CreateSegmentErrors];
+export type CreateSegmentResponses = {
     /**
-     * No Content
+     * Single segment response with internal fields
      */
-    204: void;
+    201: SegmentInternal;
 };
-export type AddMediaToSeriesResponse = AddMediaToSeriesResponses[keyof AddMediaToSeriesResponses];
-export type RemoveMediaFromSeriesData = {
-    body?: never;
+export type CreateSegmentResponse = CreateSegmentResponses[keyof CreateSegmentResponses];
+export type CreateSegmentsBatchData = {
+    body: SegmentBatchCreateRequest;
     path: {
         /**
-         * Series ID
+         * Public ID of the media
          */
-        id: number;
+        mediaId: string;
         /**
-         * Media ID
+         * Episode number
          */
-        mediaId: number;
+        episodeNumber: number;
     };
     query?: never;
-    url: '/v1/media/series/{id}/media/{mediaId}';
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments/batch';
 };
-export type RemoveMediaFromSeriesErrors = {
+export type CreateSegmentsBatchErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (API key)
      */
     401: Error401;
     /**
@@ -3343,41 +3576,49 @@ export type RemoveMediaFromSeriesErrors = {
      */
     500: Error500;
 };
-export type RemoveMediaFromSeriesError = RemoveMediaFromSeriesErrors[keyof RemoveMediaFromSeriesErrors];
-export type RemoveMediaFromSeriesResponses = {
+export type CreateSegmentsBatchError = CreateSegmentsBatchErrors[keyof CreateSegmentsBatchErrors];
+export type CreateSegmentsBatchResponses = {
     /**
-     * No Content
+     * Batch segment creation result
      */
-    204: void;
-};
-export type RemoveMediaFromSeriesResponse = RemoveMediaFromSeriesResponses[keyof RemoveMediaFromSeriesResponses];
-export type UpdateSeriesMediaData = {
-    body: {
+    201: {
         /**
-         * New position in the series (1-indexed)
+         * Number of segments successfully created
          */
-        position: number;
+        created: number;
+        /**
+         * Number of segments skipped due to duplicate UUIDs
+         */
+        skipped: number;
     };
+};
+export type CreateSegmentsBatchResponse = CreateSegmentsBatchResponses[keyof CreateSegmentsBatchResponses];
+export type DeleteSegmentData = {
+    body?: never;
     path: {
         /**
-         * Series ID
+         * Public ID of the media
          */
-        id: number;
+        mediaId: string;
+        /**
+         * Episode 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;
     /**
@@ -3397,32 +3638,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
+         * Public ID of the media
+         */
+        mediaId: string;
+        /**
+         * 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;
     /**
@@ -3442,37 +3691,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
+         * Public ID of the media
          */
-        id: number;
-    };
-    query?: {
+        mediaId: string;
         /**
-         * Resources to expand in the response (`character` is included by default)
+         * Episode number
+         */
+        episodeNumber: number;
+        /**
+         * 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;
     /**
@@ -3492,14 +3744,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;
@@ -3508,9 +3760,13 @@ export type GetUserQuotaData = {
 };
 export type GetUserQuotaErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (session)
+     */
+    401: Error401;
+    /**
+     * Forbidden
      */
-    401: Error401;
+    403: Error403;
     /**
      * Too Many Requests
      */
@@ -3528,43 +3784,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;
@@ -3577,7 +3796,7 @@ export type CreateUserReportErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -3605,7 +3824,7 @@ export type GetUserPreferencesData = {
 };
 export type GetUserPreferencesErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -3629,7 +3848,7 @@ export type UpdateUserPreferencesData = {
 };
 export type UpdateUserPreferencesErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -3658,7 +3877,7 @@ export type DeleteUserActivityData = {
 };
 export type DeleteUserActivityErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -3672,7 +3891,6 @@ export type DeleteUserActivityResponses = {
      * OK
      */
     200: {
-        message: string;
         deletedCount: number;
     };
 };
@@ -3682,13 +3900,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
          */
@@ -3702,7 +3920,7 @@ export type ListUserActivityData = {
 };
 export type ListUserActivityErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -3717,10 +3935,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' | 'SHARE';
+        segmentId?: number;
+        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;
@@ -3729,16 +3981,12 @@ export type GetUserActivityHeatmapData = {
          * Number of days to include in the heatmap
          */
         days?: number;
-        /**
-         * Filter by activity type
-         */
-        activityType?: ActivityType;
     };
     url: '/v1/user/activity/heatmap';
 };
 export type GetUserActivityHeatmapErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -3753,10 +4001,10 @@ export type GetUserActivityHeatmapResponses = {
      */
     200: {
         /**
-         * Map of YYYY-MM-DD date strings to activity counts
+         * Map of YYYY-MM-DD date strings to per-type activity counts
          */
-        counts: {
-            [key: string]: number;
+        activityByDay: {
+            [key: string]: HeatmapDayCounts;
         };
     };
 };
@@ -3774,7 +4022,7 @@ export type GetUserActivityStatsData = {
 };
 export type GetUserActivityStatsErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -3792,10 +4040,7 @@ export type GetUserActivityStatsResponses = {
         totalExports: number;
         totalPlays: number;
         totalListAdds: number;
-        /**
-         * Consecutive days with at least one activity
-         */
-        streakDays: number;
+        totalShares: number;
         topMedia: Array<{
             mediaId: number;
             count: number;
@@ -3803,6 +4048,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;
@@ -3811,7 +4120,7 @@ export type ExportUserDataData = {
 };
 export type ExportUserDataErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -3835,7 +4144,7 @@ export type ListUserLabsData = {
 };
 export type ListUserLabsErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -3851,6 +4160,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;
@@ -3860,19 +4235,13 @@ export type ListCollectionsData = {
          */
         visibility?: 'public' | 'private';
         /**
-         * Cursor offset for pagination
+         * Opaque pagination cursor token
          */
-        cursor?: number;
-        /**
-         * Page number (1-indexed)
-         *
-         * @deprecated
-         */
-        page?: number;
+        cursor?: string;
         /**
          * Items per page
          */
-        limit?: number;
+        take?: number;
     };
     url: '/v1/collections';
 };
@@ -3882,7 +4251,7 @@ export type ListCollectionsErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -3918,7 +4287,7 @@ export type CreateCollectionErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -3946,9 +4315,9 @@ export type DeleteCollectionData = {
     body?: never;
     path: {
         /**
-         * Collection ID
+         * Collection public ID
          */
-        id: number;
+        id: string;
     };
     query?: never;
     url: '/v1/collections/{id}';
@@ -3959,7 +4328,7 @@ export type DeleteCollectionErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -3991,25 +4360,19 @@ export type GetCollectionData = {
     body?: never;
     path: {
         /**
-         * Collection ID
+         * Collection public ID
          */
-        id: number;
+        id: string;
     };
     query?: {
         /**
-         * Cursor offset for paginated segments
-         */
-        cursor?: number;
-        /**
-         * Page number (1-indexed)
-         *
-         * @deprecated
+         * Opaque pagination cursor token for paginated segments
          */
-        page?: number;
+        cursor?: string;
         /**
          * Items per page
          */
-        limit?: number;
+        take?: number;
     };
     url: '/v1/collections/{id}';
 };
@@ -4019,7 +4382,7 @@ export type GetCollectionErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -4054,9 +4417,9 @@ export type UpdateCollectionData = {
     };
     path: {
         /**
-         * Collection ID
+         * Collection public ID
          */
-        id: number;
+        id: string;
     };
     query?: never;
     url: '/v1/collections/{id}';
@@ -4067,7 +4430,7 @@ export type UpdateCollectionErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -4090,38 +4453,145 @@ export type UpdateCollectionErrors = {
 export type UpdateCollectionError = UpdateCollectionErrors[keyof UpdateCollectionErrors];
 export type UpdateCollectionResponses = {
     /**
-     * OK
+     * OK
+     */
+    200: Collection;
+};
+export type UpdateCollectionResponse = UpdateCollectionResponses[keyof UpdateCollectionResponses];
+export type AddSegmentToCollectionData = {
+    body: {
+        /**
+         * Public ID or UUID of the segment to add
+         */
+        segmentId: string;
+        /**
+         * Optional annotation
+         */
+        note?: string;
+    };
+    path: {
+        /**
+         * Collection public ID
+         */
+        id: string;
+    };
+    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 public ID
+         */
+        id: string;
+        /**
+         * Segment ID
+         */
+        segmentId: number;
+    };
+    query?: never;
+    url: '/v1/collections/{id}/segments/{segmentId}';
+};
+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
      */
-    200: Collection;
+    204: void;
 };
-export type UpdateCollectionResponse = UpdateCollectionResponses[keyof UpdateCollectionResponses];
-export type AddSegmentToCollectionData = {
+export type RemoveSegmentFromCollectionResponse = RemoveSegmentFromCollectionResponses[keyof RemoveSegmentFromCollectionResponses];
+export type UpdateCollectionSegmentData = {
     body: {
         /**
-         * UUID of the segment to add
+         * New position in the collection
          */
-        segmentUuid: string;
+        position?: number;
         /**
-         * Optional annotation
+         * Updated annotation
          */
         note?: string;
     };
     path: {
         /**
-         * Collection ID
+         * Collection public ID
          */
-        id: number;
+        id: string;
+        /**
+         * Segment ID
+         */
+        segmentId: number;
     };
     query?: never;
-    url: '/v1/collections/{id}/segments';
+    url: '/v1/collections/{id}/segments/{segmentId}';
 };
-export type AddSegmentToCollectionErrors = {
+export type UpdateCollectionSegmentErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -4141,36 +4611,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
+         * Collection public ID
          */
-        id: number;
+        id: string;
+    };
+    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;
     /**
@@ -4190,45 +4665,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
+         * Collection public ID
          */
-        uuid: string;
+        id: 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;
     /**
@@ -4248,14 +4710,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;
@@ -4264,7 +4726,7 @@ export type GetAdminDashboardData = {
 };
 export type GetAdminDashboardErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -4356,7 +4818,7 @@ export type GetAdminHealthData = {
 };
 export type GetAdminHealthErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -4418,7 +4880,7 @@ export type TriggerReindexErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -4454,7 +4916,7 @@ export type ListAdminQueueStatsErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -4476,15 +4938,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];
@@ -4505,7 +4967,7 @@ export type GetAdminQueueErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -4590,7 +5052,7 @@ export type ListAdminQueueFailedErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -4615,19 +5077,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];
@@ -4648,7 +5110,7 @@ export type RetryAdminQueueFailedErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -4670,12 +5132,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];
@@ -4696,7 +5158,7 @@ export type PurgeAdminQueueFailedErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -4718,27 +5180,105 @@ 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 = {
+    /**
+     * 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;
+    /**
+     * 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
          */
@@ -4760,19 +5300,19 @@ export type ListAdminReportsData = {
          */
         'target.episodeNumber'?: number;
         /**
-         * Filter by target segment UUID
+         * Filter by target segment ID
          */
-        'target.segmentUuid'?: string;
+        'target.segmentId'?: number;
         /**
-         * Filter by review check run ID
+         * Filter by audit run ID
          */
-        reviewCheckRunId?: number;
+        auditRunId?: number;
     };
     url: '/v1/admin/reports';
 };
 export type ListAdminReportsErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -4813,7 +5353,7 @@ export type UpdateAdminReportErrors = {
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -4841,24 +5381,15 @@ export type UpdateAdminReportResponses = {
     200: Report;
 };
 export type UpdateAdminReportResponse = UpdateAdminReportResponses[keyof UpdateAdminReportResponses];
-export type RunAdminReviewData = {
+export type ListAdminMediaAuditsData = {
     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';
+    query?: never;
+    url: '/v1/admin/media/audits';
 };
-export type RunAdminReviewErrors = {
+export type ListAdminMediaAuditsErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -4874,29 +5405,53 @@ export type RunAdminReviewErrors = {
      */
     500: Error500;
 };
-export type RunAdminReviewError = RunAdminReviewErrors[keyof RunAdminReviewErrors];
-export type RunAdminReviewResponses = {
+export type ListAdminMediaAuditsError = ListAdminMediaAuditsErrors[keyof ListAdminMediaAuditsErrors];
+export type ListAdminMediaAuditsResponses = {
     /**
-     * Check run completed
+     * OK
      */
-    200: RunReviewResponse;
+    200: Array<MediaAudit>;
 };
-export type RunAdminReviewResponse = RunAdminReviewResponses[keyof RunAdminReviewResponses];
-export type ListAdminReviewChecksData = {
-    body?: never;
-    path?: never;
+export type ListAdminMediaAuditsResponse = ListAdminMediaAuditsResponses[keyof ListAdminMediaAuditsResponses];
+export type UpdateAdminMediaAuditData = {
+    body: {
+        /**
+         * New threshold values
+         */
+        threshold?: {
+            [key: string]: unknown;
+        };
+        /**
+         * Enable or disable this audit
+         */
+        enabled?: boolean;
+    };
+    path: {
+        /**
+         * Audit name identifier
+         */
+        name: string;
+    };
     query?: never;
-    url: '/v1/admin/review/checks';
+    url: '/v1/admin/media/audits/{name}';
 };
-export type ListAdminReviewChecksErrors = {
+export type UpdateAdminMediaAuditErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
      * Forbidden
      */
     403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
     /**
      * Too Many Requests
      */
@@ -4906,43 +5461,33 @@ export type ListAdminReviewChecksErrors = {
      */
     500: Error500;
 };
-export type ListAdminReviewChecksError = ListAdminReviewChecksErrors[keyof ListAdminReviewChecksErrors];
-export type ListAdminReviewChecksResponses = {
+export type UpdateAdminMediaAuditError = UpdateAdminMediaAuditErrors[keyof UpdateAdminMediaAuditErrors];
+export type UpdateAdminMediaAuditResponses = {
     /**
-     * OK
+     * Audit updated successfully
      */
-    200: Array<ReviewCheck>;
+    200: MediaAudit;
 };
-export type ListAdminReviewChecksResponse = ListAdminReviewChecksResponses[keyof ListAdminReviewChecksResponses];
-export type UpdateAdminReviewCheckData = {
-    body: {
-        /**
-         * New threshold values
-         */
-        threshold?: {
-            [key: string]: unknown;
-        };
+export type UpdateAdminMediaAuditResponse = UpdateAdminMediaAuditResponses[keyof UpdateAdminMediaAuditResponses];
+export type RunAdminMediaAuditData = {
+    body?: never;
+    path: {
         /**
-         * Enable or disable this check
+         * Audit name to run, or "all" to run all enabled audits
          */
-        enabled?: boolean;
+        name: string;
     };
-    path: {
+    query?: {
         /**
-         * Check name identifier
+         * Optional category filter
          */
-        name: string;
+        category?: 'ANIME' | 'JDRAMA';
     };
-    query?: never;
-    url: '/v1/admin/review/checks/{name}';
+    url: '/v1/admin/media/audits/{name}/run';
 };
-export type UpdateAdminReviewCheckErrors = {
-    /**
-     * Bad Request
-     */
-    400: Error400;
+export type RunAdminMediaAuditErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -4962,36 +5507,36 @@ export type UpdateAdminReviewCheckErrors = {
      */
     500: Error500;
 };
-export type UpdateAdminReviewCheckError = UpdateAdminReviewCheckErrors[keyof UpdateAdminReviewCheckErrors];
-export type UpdateAdminReviewCheckResponses = {
+export type RunAdminMediaAuditError = RunAdminMediaAuditErrors[keyof RunAdminMediaAuditErrors];
+export type RunAdminMediaAuditResponses = {
     /**
-     * Check updated successfully
+     * Audit run completed
      */
-    200: ReviewCheck;
+    200: RunAuditResponse;
 };
-export type UpdateAdminReviewCheckResponse = UpdateAdminReviewCheckResponses[keyof UpdateAdminReviewCheckResponses];
-export type ListAdminReviewRunsData = {
+export type RunAdminMediaAuditResponse = RunAdminMediaAuditResponses[keyof RunAdminMediaAuditResponses];
+export type ListAdminMediaAuditRunsData = {
     body?: never;
     path?: never;
     query?: {
         /**
-         * Filter by check name
+         * Filter by audit name
          */
-        checkName?: string;
+        auditName?: string;
         /**
-         * Cursor for pagination
+         * Opaque pagination cursor token
          */
-        cursor?: number;
+        cursor?: string;
         /**
          * Number of results per page
          */
-        limit?: number;
+        take?: number;
     };
-    url: '/v1/admin/review/runs';
+    url: '/v1/admin/media/audits/runs';
 };
-export type ListAdminReviewRunsErrors = {
+export type ListAdminMediaAuditRunsErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -5007,18 +5552,18 @@ export type ListAdminReviewRunsErrors = {
      */
     500: Error500;
 };
-export type ListAdminReviewRunsError = ListAdminReviewRunsErrors[keyof ListAdminReviewRunsErrors];
-export type ListAdminReviewRunsResponses = {
+export type ListAdminMediaAuditRunsError = ListAdminMediaAuditRunsErrors[keyof ListAdminMediaAuditRunsErrors];
+export type ListAdminMediaAuditRunsResponses = {
     /**
      * OK
      */
     200: {
-        runs: Array<ReviewCheckRun>;
-        pagination: CursorPagination;
+        runs: Array<MediaAuditRun>;
+        pagination: OpaqueCursorPagination;
     };
 };
-export type ListAdminReviewRunsResponse = ListAdminReviewRunsResponses[keyof ListAdminReviewRunsResponses];
-export type GetAdminReviewRunData = {
+export type ListAdminMediaAuditRunsResponse = ListAdminMediaAuditRunsResponses[keyof ListAdminMediaAuditRunsResponses];
+export type GetAdminMediaAuditRunData = {
     body?: never;
     path: {
         /**
@@ -5027,11 +5572,11 @@ export type GetAdminReviewRunData = {
         id: number;
     };
     query?: never;
-    url: '/v1/admin/review/runs/{id}';
+    url: '/v1/admin/media/audits/runs/{id}';
 };
-export type GetAdminReviewRunErrors = {
+export type GetAdminMediaAuditRunErrors = {
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
@@ -5051,37 +5596,24 @@ export type GetAdminReviewRunErrors = {
      */
     500: Error500;
 };
-export type GetAdminReviewRunError = GetAdminReviewRunErrors[keyof GetAdminReviewRunErrors];
-export type GetAdminReviewRunResponses = {
+export type GetAdminMediaAuditRunError = GetAdminMediaAuditRunErrors[keyof GetAdminMediaAuditRunErrors];
+export type GetAdminMediaAuditRunResponses = {
     /**
      * OK
      */
     200: {
-        run: ReviewCheckRun;
+        run: MediaAuditRun;
         reports: Array<Report>;
     };
 };
-export type GetAdminReviewRunResponse = GetAdminReviewRunResponses[keyof GetAdminReviewRunResponses];
-export type ListAdminReviewAllowlistData = {
+export type GetAdminMediaAuditRunResponse = GetAdminMediaAuditRunResponses[keyof GetAdminMediaAuditRunResponses];
+export type GetAnnouncementData = {
     body?: never;
     path?: never;
-    query?: {
-        /**
-         * Filter by check name
-         */
-        checkName?: string;
-    };
-    url: '/v1/admin/review/allowlist';
+    query?: never;
+    url: '/v1/admin/announcement';
 };
-export type ListAdminReviewAllowlistErrors = {
-    /**
-     * Unauthorized
-     */
-    401: Error401;
-    /**
-     * Forbidden
-     */
-    403: Error403;
+export type GetAnnouncementErrors = {
     /**
      * Too Many Requests
      */
@@ -5091,54 +5623,45 @@ export type ListAdminReviewAllowlistErrors = {
      */
     500: Error500;
 };
-export type ListAdminReviewAllowlistError = ListAdminReviewAllowlistErrors[keyof ListAdminReviewAllowlistErrors];
-export type ListAdminReviewAllowlistResponses = {
+export type GetAnnouncementError = GetAnnouncementErrors[keyof GetAnnouncementErrors];
+export type GetAnnouncementResponses = {
     /**
      * OK
      */
-    200: Array<ReviewAllowlist>;
+    200: {
+        message: string;
+        type: 'info' | 'warning' | 'maintenance';
+        active: boolean;
+    };
+    /**
+     * No announcement set
+     */
+    204: void;
 };
-export type ListAdminReviewAllowlistResponse = ListAdminReviewAllowlistResponses[keyof ListAdminReviewAllowlistResponses];
-export type CreateAdminReviewAllowlistEntryData = {
+export type GetAnnouncementResponse = GetAnnouncementResponses[keyof GetAnnouncementResponses];
+export type UpdateAnnouncementData = {
     body: {
-        /**
-         * Check name to allowlist for
-         */
-        checkName: string;
-        /**
-         * Media ID to allowlist
-         */
-        mediaId: number;
-        /**
-         * Episode number (for episode-level checks)
-         */
-        episodeNumber?: number;
-        /**
-         * Reason for allowlisting
-         */
-        reason?: string;
+        message: string;
+        type: 'info' | 'warning' | 'maintenance';
+        active: boolean;
     };
     path?: never;
     query?: never;
-    url: '/v1/admin/review/allowlist';
+    url: '/v1/admin/announcement';
 };
-export type CreateAdminReviewAllowlistEntryErrors = {
+export type UpdateAnnouncementErrors = {
     /**
      * Bad Request
      */
     400: Error400;
     /**
-     * Unauthorized
+     * Unauthorized (session)
      */
     401: Error401;
     /**
      * Forbidden
      */
     403: Error403;
-    /**
-     * Conflict
-     */
-    409: Error409;
     /**
      * Too Many Requests
      */
@@ -5148,53 +5671,16 @@ export type CreateAdminReviewAllowlistEntryErrors = {
      */
     500: Error500;
 };
-export type CreateAdminReviewAllowlistEntryError = CreateAdminReviewAllowlistEntryErrors[keyof CreateAdminReviewAllowlistEntryErrors];
-export type CreateAdminReviewAllowlistEntryResponses = {
+export type UpdateAnnouncementError = UpdateAnnouncementErrors[keyof UpdateAnnouncementErrors];
+export type UpdateAnnouncementResponses = {
     /**
-     * Added to allowlist
+     * Announcement updated
      */
-    201: ReviewAllowlist;
-};
-export type CreateAdminReviewAllowlistEntryResponse = CreateAdminReviewAllowlistEntryResponses[keyof CreateAdminReviewAllowlistEntryResponses];
-export type DeleteAdminReviewAllowlistEntryData = {
-    body?: never;
-    path: {
-        /**
-         * Allowlist entry ID
-         */
-        id: number;
+    200: {
+        message: string;
+        type: 'info' | 'warning' | 'maintenance';
+        active: boolean;
     };
-    query?: never;
-    url: '/v1/admin/review/allowlist/{id}';
-};
-export type DeleteAdminReviewAllowlistEntryErrors = {
-    /**
-     * Unauthorized
-     */
-    401: Error401;
-    /**
-     * Forbidden
-     */
-    403: Error403;
-    /**
-     * Not Found
-     */
-    404: Error404;
-    /**
-     * Too Many Requests
-     */
-    429: Error429;
-    /**
-     * Internal Server Error
-     */
-    500: Error500;
-};
-export type DeleteAdminReviewAllowlistEntryError = DeleteAdminReviewAllowlistEntryErrors[keyof DeleteAdminReviewAllowlistEntryErrors];
-export type DeleteAdminReviewAllowlistEntryResponses = {
-    /**
-     * Removed from allowlist
-     */
-    204: void;
 };
-export type DeleteAdminReviewAllowlistEntryResponse = DeleteAdminReviewAllowlistEntryResponses[keyof DeleteAdminReviewAllowlistEntryResponses];
+export type UpdateAnnouncementResponse = UpdateAnnouncementResponses[keyof UpdateAnnouncementResponses];
 //# sourceMappingURL=types.gen.d.ts.map