@brigadasos/nadeshiko-sdk 1.4.0-dev.9621982 → 1.4.2-dev.a13aba0

package/dist/types.gen.d.ts

@@ -1,204 +1,360 @@
 export type ClientOptions = {
     baseUrl: 'http://localhost:5000' | 'https://api.nadeshiko.co' | (string & {});
 };
+/**
+ * A media filter entry with optional episode restriction
+ */
+export type MediaFilterItem = {
+    /**
+     * Media ID to filter
+     */
+    mediaId: number;
+    /**
+     * Specific episodes (omit for all episodes)
+     */
+    episodes?: Array<number>;
+};
 /**
  * Media category type
  */
 export type Category = 'ANIME' | 'JDRAMA';
 /**
- * Media information included in search results
+ * Content rating level for the segment
  */
-export type SearchResultMedia = {
+export type ContentRating = 'SAFE' | 'SUGGESTIVE' | 'QUESTIONABLE' | 'EXPLICIT';
+/**
+ * Search filters for narrowing segment results
+ */
+export type SearchFilters = {
     /**
-     * Unique identifier for the media
+     * Media inclusion/exclusion filters
      */
-    mediaId: number;
+    media?: {
+        /**
+         * Include only segments from these media (with optional episode filter)
+         */
+        include?: Array<MediaFilterItem>;
+        /**
+         * Exclude segments from these media (with optional episode filter)
+         */
+        exclude?: Array<MediaFilterItem>;
+    };
     /**
-     * Romaji transliteration of the media name
+     * Media category filter
      */
-    nameRomaji: string;
+    category?: Array<Category>;
     /**
-     * English name of the media
+     * Content ratings to include (omit for all ratings)
      */
-    nameEn?: string;
+    contentRating?: Array<ContentRating>;
     /**
-     * Original Japanese name of the media
+     * Segment status filter
      */
-    nameJa?: string;
+    status?: Array<'DELETED' | 'ACTIVE' | 'SUSPENDED' | 'VERIFIED' | 'INVALID' | 'TOO_LONG'>;
     /**
-     * URL to the cover image
+     * Content character count range filter
      */
-    coverUrl?: string;
+    segmentLengthChars?: {
+        /**
+         * Minimum content length
+         */
+        min?: number;
+        /**
+         * Maximum content length
+         */
+        max?: number;
+    };
     /**
-     * URL to the banner image
+     * Segment audio duration range filter (in milliseconds)
      */
-    bannerUrl?: string;
-    category: Category;
+    segmentDurationMs?: {
+        /**
+         * Minimum duration in ms
+         */
+        min?: number;
+        /**
+         * Maximum duration in ms
+         */
+        max?: number;
+    };
 };
 /**
- * Japanese content in search results with optional highlight
+ * Resource to expand in the response includes block
  */
-export type JapaneseSearchContent = {
+export type IncludeExpansion = 'media';
+export type SearchRequest = {
     /**
-     * Original Japanese content of the segment
+     * What to search for (omit for queryless browse)
      */
-    content: string;
+    query?: {
+        /**
+         * Search expression (supports boolean operators, wildcards, phrase matching)
+         */
+        search?: string;
+        /**
+         * Whether to use exact phrase matching
+         */
+        exactMatch?: boolean;
+    };
     /**
-     * Japanese content with search terms highlighted
+     * Max amount of entries by response
      */
-    highlight?: string;
-};
-/**
- * Translation content in search results with optional highlight
- */
-export type TranslationSearchContent = {
+    limit?: number;
     /**
-     * Translated content
+     * Current page of search
      */
-    content?: string;
+    cursor?: Array<number>;
     /**
-     * Translated content with search terms highlighted
+     * Sort configuration
      */
-    highlight?: string;
+    sort?: {
+        /**
+         * Sort mode
+         */
+        mode?: 'ASC' | 'DESC' | 'NONE' | 'TIME_ASC' | 'TIME_DESC' | 'RANDOM';
+        /**
+         * Non-negative integer seed for deterministic random sorting (only used when mode is RANDOM)
+         */
+        seed?: number;
+    };
+    filters?: SearchFilters;
     /**
-     * Whether the translation was machine-translated
+     * Resources to expand in the response includes block
      */
-    isMachineTranslated: boolean;
+    include?: Array<IncludeExpansion>;
 };
 /**
- * Morphological analysis token
+ * Segment with content, optional highlights, and media URLs
  */
-export type Morpheme = {
+export type Segment = {
     /**
-     * Surface form of the token as it appears in the text
+     * Unique identifier for the segment
      */
-    surface: string;
+    uuid: string;
     /**
-     * Reading in katakana
+     * Position of the segment within the episode
      */
-    reading: string;
+    position: number;
     /**
-     * Dictionary/base form of the word
+     * Segment status
      */
-    baseform: string;
+    status: 'DELETED' | 'ACTIVE' | 'SUSPENDED' | 'VERIFIED' | 'INVALID' | 'TOO_LONG';
     /**
-     * Pronunciation in katakana
+     * Start time of the segment in milliseconds from the beginning of the episode
      */
-    pronunciation: string;
+    startTimeMs: number;
     /**
-     * Full part-of-speech tag array
+     * End time of the segment in milliseconds from the beginning of the episode
      */
-    pos: Array<string>;
+    endTimeMs: number;
+    contentRating: ContentRating;
     /**
-     * Short part-of-speech label (first element of pos array)
+     * Episode number this segment belongs to
      */
-    posShort: string;
+    episode: number;
     /**
-     * Character offset where the token begins in the original text
+     * Media ID this segment belongs to
      */
-    begin: number;
+    mediaId: number;
+    textJa: {
+        /**
+         * Original Japanese content
+         */
+        content: string;
+        /**
+         * Japanese content with search terms highlighted
+         */
+        highlight?: string;
+    };
+    textEn: {
+        /**
+         * English translation
+         */
+        content: string;
+        /**
+         * Whether the translation was machine-translated
+         */
+        isMachineTranslated: boolean;
+        /**
+         * English content with search terms highlighted
+         */
+        highlight?: string;
+    };
+    textEs: {
+        /**
+         * Spanish translation
+         */
+        content: string;
+        /**
+         * Whether the translation was machine-translated
+         */
+        isMachineTranslated: boolean;
+        /**
+         * Spanish content with search terms highlighted
+         */
+        highlight?: string;
+    };
     /**
-     * Character offset where the token ends in the original text
+     * URLs to media resources for this segment
      */
-    end: number;
+    urls: {
+        /**
+         * URL to the subtitle image snapshot
+         */
+        imageUrl: string;
+        /**
+         * URL to the audio clip for this segment
+         */
+        audioUrl: string;
+        /**
+         * URL to the video clip for this segment
+         */
+        videoUrl: string;
+    };
+};
+/**
+ * Map of external IDs keyed by source. Only sources with values are included.
+ */
+export type ExternalId = {
     /**
-     * Pitch accent type — mora position(s) where the pitch drops. 0 = heiban (flat), 1 = atamadaka, 2+ = nakadaka/odaka. Comma-separated in UniDic feature[24]. Null if not available.
-     *
+     * AniList ID
      */
-    pitchAccentType: Array<number>;
+    anilist?: string;
     /**
-     * Compound accent connection rule from UniDic feature[25]. Values like C1-C5, F1-F6, P1-P13. Null if not available.
-     *
+     * IMDB ID
      */
-    pitchCompoundRule: string;
+    imdb?: string;
     /**
-     * Accent modification rule from UniDic feature[26]. Values like M1, M2, M4. Null if not available.
-     *
+     * TVDB ID
      */
-    pitchModificationRule: string;
+    tvdb?: string;
 };
 /**
- * Segment details in search results
+ * Japanese voice actor (seiyuu)
  */
-export type SearchResultSegment = {
+export type Seiyuu = {
     /**
-     * Segment status
+     * AniList staff ID
      */
-    status: 'DELETED' | 'ACTIVE' | 'SUSPENDED' | 'VERIFIED' | 'INVALID' | 'TOO_LONG';
+    id: number;
     /**
-     * Unique identifier for the segment
+     * Japanese name of the voice actor
      */
-    uuid: string;
+    nameJa: string;
     /**
-     * Position of the segment within the episode
+     * English name of the voice actor
      */
-    position: number;
+    nameEn: string;
+    /**
+     * Profile image URL
+     */
+    imageUrl: string;
+};
+/**
+ * Character appearing in a media with their voice actor and role
+ */
+export type MediaCharacter = {
     /**
-     * Timestamp in H:MM:SS.ffffff format indicating when the segment starts
+     * AniList character ID
      */
-    startTime: string;
+    id: number;
     /**
-     * Timestamp in H:MM:SS.ffffff format indicating when the segment ends
+     * Japanese name of the character
      */
-    endTime: string;
+    nameJa: string;
     /**
-     * Episode number where the segment appears
+     * English name of the character
      */
-    episodeNumber: number;
-    textJa: JapaneseSearchContent;
-    textEn: TranslationSearchContent;
-    textEs: TranslationSearchContent;
+    nameEn: string;
     /**
-     * Whether the segment contains NSFW content
+     * Character image URL
      */
-    isNsfw: boolean;
+    imageUrl: string;
+    seiyuu: Seiyuu;
     /**
-     * Morphological analysis of the Japanese content
+     * Character's role in the media
      */
-    morphemes?: Array<Morpheme>;
+    role: 'MAIN' | 'SUPPORTING' | 'BACKGROUND';
 };
 /**
- * URLs to media resources for a segment
+ * Media entry with full metadata
  */
-export type SearchResultUrls = {
+export type Media = {
     /**
-     * URL to the subtitle image snapshot
+     * Unique identifier for the media
      */
-    imageUrl?: string;
+    id: number;
+    externalIds: ExternalId;
     /**
-     * URL to the audio clip for this segment
+     * Original Japanese name of the media
      */
-    audioUrl?: string;
+    nameJa: string;
     /**
-     * URL to the video clip for this segment
+     * Romaji transliteration of the media name
      */
-    videoUrl?: string;
-};
-/**
- * A complete search result combining media info, segment details, and URLs
- */
-export type SearchResult = {
+    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>;
+    /**
+     * Full URL to the cover image
+     */
+    coverUrl: string;
+    /**
+     * Full URL to the banner image
+     */
+    bannerUrl: string;
+    /**
+     * Start date of the media (first airing/release)
+     */
+    startDate: string;
+    /**
+     * End date of the media (last airing/release)
+     */
+    endDate?: string;
+    category: Category;
+    /**
+     * Total number of subtitle segments available
+     */
+    segmentCount: number;
     /**
-     * Media information for this result
+     * Total number of episodes available
+     */
+    episodeCount: number;
+    /**
+     * Animation studio that produced the media
+     */
+    studio: string;
+    /**
+     * Airing season label for the media
      */
-    media: SearchResultMedia;
+    seasonName: string;
     /**
-     * Segment details including translations
+     * Airing year for the media
      */
-    segment: SearchResultSegment;
+    seasonYear: number;
     /**
-     * URLs to media resources (images, audio, video)
+     * Characters appearing in the media with their voice actors
      */
-    urls: SearchResultUrls;
+    characters?: Array<MediaCharacter>;
 };
 /**
  * Pagination metadata for search results
  */
 export type PaginationInfo = {
-    /**
-     * Number of results returned in this page
-     */
-    pageSize?: number;
     /**
      * Whether there are more results after this page
      */
@@ -211,14 +367,57 @@ export type PaginationInfo = {
      * Whether estimatedTotalHits is exact or a lower bound
      */
     estimatedTotalHitsRelation?: 'EXACT' | 'LOWER_BOUND';
+    /**
+     * Cursor for fetching the next page (undefined when hasMore is false)
+     */
+    cursor?: Array<number>;
 };
-export type SearchHealthCheckResponse = {
-    results?: Array<SearchResult>;
+export type SearchResponse = {
+    segments?: Array<Segment>;
+    includes?: {
+        /**
+         * Media objects keyed by mediaId
+         */
+        media?: {
+            [key: string]: Media;
+        };
+    };
     pagination?: PaginationInfo;
+};
+/**
+ * Bad Request error response
+ */
+export type Error400 = {
     /**
-     * Cursor for pagination
+     * Specific error code for programmatic handling
      */
-    cursor?: Array<number>;
+    code: 'VALIDATION_FAILED' | 'INVALID_JSON' | 'INVALID_REQUEST';
+    /**
+     * A short, human-readable summary of the problem
+     */
+    title: string;
+    /**
+     * A human-readable explanation specific to this occurrence
+     */
+    detail: string;
+    /**
+     * A URI reference that identifies the problem type (e.g., GitHub issues link)
+     */
+    type?: string;
+    /**
+     * A URI reference that identifies the specific occurrence (e.g., trace ID)
+     */
+    instance?: string;
+    /**
+     * The HTTP status code
+     */
+    status: 400;
+    /**
+     * Optional map of field names to their error messages (for validation errors)
+     */
+    errors?: {
+        [key: string]: string;
+    };
 };
 /**
  * Unauthorized error response
@@ -360,180 +559,42 @@ export type Error500 = {
         [key: string]: string;
     };
 };
-export type SearchRequest = {
-    /**
-     * Text or sentence to search (null to search without query)
-     */
-    query?: string;
+export type SearchStatsRequest = {
     /**
-     * Max amount of entries by response
+     * What to search for (omit for queryless stats)
      */
-    limit?: number;
-    /**
-     * Unique ID from segment (Useful to get a specific segment)
-     */
-    uuid?: string;
-    /**
-     * Media category filter
-     */
-    category?: Array<Category>;
-    /**
-     * Unique ID from media
-     */
-    mediaId?: number;
-    /**
-     * Array of episodes to get
-     */
-    episode?: Array<number>;
-    /**
-     * Non-negative integer seed for deterministic random sorting
-     */
-    randomSeed?: number;
-    /**
-     * Order by amount of characters
-     */
-    contentSort?: 'ASC' | 'DESC' | 'NONE' | 'TIME_ASC' | 'TIME_DESC' | 'RANDOM';
-    /**
-     * Current page of search
-     */
-    cursor?: Array<number>;
-    /**
-     * Whether to use exact phrase matching
-     */
-    exactMatch?: boolean;
-    /**
-     * Minimum content length
-     */
-    minLength?: number;
-    /**
-     * Maximum content length
-     */
-    maxLength?: number;
-    /**
-     * Media IDs to exclude from results
-     */
-    excludedMediaIds?: Array<number>;
-    /**
-     * Segment status filter
-     */
-    status?: Array<'DELETED' | 'ACTIVE' | 'SUSPENDED' | 'VERIFIED' | 'INVALID' | 'TOO_LONG'>;
-    /**
-     * Media filter with episodes
-     */
-    media?: Array<{
-        mediaId: number;
+    query?: {
         /**
-         * Array of episode numbers
+         * Search expression (supports boolean operators, wildcards, phrase matching)
          */
-        episodes: Array<number>;
-    }>;
-};
-export type SearchResponse = {
-    results?: Array<SearchResult>;
-    pagination?: PaginationInfo;
-    /**
-     * Cursor for pagination
-     */
-    cursor?: Array<number>;
-};
-/**
- * Bad Request error response
- */
-export type Error400 = {
-    /**
-     * Specific error code for programmatic handling
-     */
-    code: 'VALIDATION_FAILED' | 'INVALID_JSON' | 'INVALID_REQUEST';
-    /**
-     * A short, human-readable summary of the problem
-     */
-    title: string;
-    /**
-     * A human-readable explanation specific to this occurrence
-     */
-    detail: string;
-    /**
-     * A URI reference that identifies the problem type (e.g., GitHub issues link)
-     */
-    type?: string;
-    /**
-     * A URI reference that identifies the specific occurrence (e.g., trace ID)
-     */
-    instance?: string;
-    /**
-     * The HTTP status code
-     */
-    status: 400;
-    /**
-     * Optional map of field names to their error messages (for validation errors)
-     */
-    errors?: {
-        [key: string]: string;
+        search?: string;
+        /**
+         * Whether to use exact phrase matching
+         */
+        exactMatch?: boolean;
     };
-};
-export type SearchStatsRequest = {
-    /**
-     * Text or sentence to search
-     */
-    query?: string;
-    /**
-     * Media category filter
-     */
-    category?: Array<Category>;
-    /**
-     * Whether to use exact phrase matching
-     */
-    exactMatch?: boolean;
-    /**
-     * Minimum content length
-     */
-    minLength?: number;
-    /**
-     * Maximum content length
-     */
-    maxLength?: number;
-    /**
-     * Media IDs to exclude from results
-     */
-    excludedMediaIds?: Array<number>;
-    /**
-     * Restrict stats to these media IDs (for list-scoped stats)
-     */
-    mediaIds?: Array<number>;
+    filters?: SearchFilters;
     /**
-     * Segment status filter
+     * Resources to expand in the response includes block
      */
-    status?: Array<'DELETED' | 'ACTIVE' | 'SUSPENDED' | 'VERIFIED' | 'INVALID' | 'TOO_LONG'>;
+    include?: Array<IncludeExpansion>;
 };
 /**
- * Search result statistics grouped by media
+ * Search hit statistics for a single media
  */
 export type MediaSearchStats = {
     /**
-     * Unique identifier for the media
-     */
-    mediaId?: number;
-    category?: Category;
-    /**
-     * Romaji transliteration of the media name
-     */
-    nameRomaji?: string;
-    /**
-     * English name of the media
-     */
-    nameEn?: string;
-    /**
-     * Original Japanese name of the media
+     * Media identifier (look up full details in includes.media)
      */
-    nameJa?: string;
+    mediaId: number;
     /**
-     * Total number of segments found for this media
+     * Number of matching segments found in this media
      */
-    segmentCount?: number;
+    matchCount: number;
     /**
      * Mapping of episode numbers to segment hit counts
      */
-    episodeHits?: {
+    episodeHits: {
         [key: string]: number;
     };
 };
@@ -550,41 +611,47 @@ export type CategoryCount = {
 export type SearchStatsResponse = {
     media?: Array<MediaSearchStats>;
     categories?: Array<CategoryCount>;
+    includes?: {
+        /**
+         * Media objects keyed by mediaId
+         */
+        media?: {
+            [key: string]: Media;
+        };
+    };
 };
 export type SearchMultipleRequest = {
     /**
-     * List of words to search for
+     * What to search for
      */
-    words: Array<string>;
+    query: {
+        /**
+         * List of words to search for
+         */
+        words: Array<string>;
+        /**
+         * Whether to use exact matching
+         */
+        exactMatch?: boolean;
+    };
+    filters?: SearchFilters;
     /**
-     * Whether to use exact matching
+     * Resources to expand in the response includes block
      */
-    exactMatch?: boolean;
+    include?: Array<IncludeExpansion>;
 };
 /**
- * Media entry containing word matches
+ * Media match count entry
  */
 export type WordMatchMedia = {
     /**
-     * Unique identifier for the media
-     */
-    mediaId?: number;
-    /**
-     * English name of the media
-     */
-    nameEn?: string;
-    /**
-     * Original Japanese name of the media
-     */
-    nameJa?: string;
-    /**
-     * Romaji transliteration of the media name
+     * Media identifier (look up full details in includes.media)
      */
-    nameRomaji?: string;
+    mediaId: number;
     /**
      * Number of times the word appears in this media
      */
-    matchCount?: number;
+    matchCount: number;
 };
 /**
  * Word matching result with occurrences across media
@@ -609,49 +676,40 @@ export type WordMatch = {
 };
 export type SearchMultipleResponse = {
     results?: Array<WordMatch>;
+    includes?: {
+        /**
+         * Media objects keyed by mediaId
+         */
+        media?: {
+            [key: string]: Media;
+        };
+    };
 };
 /**
- * Map of external IDs keyed by source. Only sources with values are included.
+ * Resource to expand in media responses
  */
-export type ExternalId = {
-    /**
-     * AniList ID
-     */
-    anilist?: string;
-    /**
-     * IMDB ID
-     */
-    imdb?: string;
-    /**
-     * TVDB ID
-     */
-    tvdb?: string;
-};
+export type MediaIncludeExpansion = 'media' | 'media.characters';
 /**
- * Japanese voice actor (seiyuu)
+ * Cursor pagination metadata
  */
-export type Seiyuu = {
-    /**
-     * AniList staff ID
-     */
-    id: number;
-    /**
-     * Japanese name of the voice actor
-     */
-    nameJa: string;
+export type CursorPagination = {
     /**
-     * English name of the voice actor
+     * Whether more results are available
      */
-    nameEn: string;
+    hasMore: boolean;
     /**
-     * Profile image URL
+     * Cursor for the next page (`null` when `hasMore` is `false`)
      */
-    imageUrl: string;
+    cursor: number;
+};
+export type MediaListResponse = {
+    media: Array<Media>;
+    pagination: CursorPagination;
 };
 /**
- * Anime character
+ * Character data for creating/updating media
  */
-export type Character = {
+export type CharacterInput = {
     /**
      * AniList character ID
      */
@@ -668,51 +726,31 @@ export type Character = {
      * Character image URL
      */
     imageUrl: string;
-    seiyuu: Seiyuu;
-};
-/**
- * Character appearing in a media with their role
- */
-export type MediaCharacter = {
-    character: Character;
     /**
      * Character's role in the media
      */
     role: 'MAIN' | 'SUPPORTING' | 'BACKGROUND';
-};
-/**
- * Media collection list
- */
-export type List = {
-    /**
-     * List ID
-     */
-    id: number;
     /**
-     * Name of the list
+     * AniList staff ID for the Japanese voice actor
      */
-    name: string;
+    seiyuuId: number;
     /**
-     * Type of list
+     * Japanese name of the voice actor
      */
-    type: 'SERIES' | 'CUSTOM' | 'SEGMENT';
+    seiyuuNameJa: string;
     /**
-     * User ID who owns the list (1 = admin)
+     * English name of the voice actor
      */
-    userId: number;
+    seiyuuNameEn: string;
     /**
-     * Visibility of the list
+     * Voice actor profile image URL
      */
-    visibility: 'PUBLIC' | 'PRIVATE';
+    seiyuuImageUrl: string;
 };
 /**
- * Media entry with full metadata
+ * Request body for creating a new media entry
  */
-export type Media = {
-    /**
-     * Unique identifier for the media
-     */
-    id: number;
+export type MediaCreateRequest = {
     externalIds?: ExternalId;
     /**
      * Original Japanese name of the media
@@ -739,13 +777,9 @@ export type Media = {
      */
     genres: Array<string>;
     /**
-     * Full URL to the cover image
-     */
-    coverUrl: string;
-    /**
-     * Full URL to the banner image
+     * Storage backend for media assets
      */
-    bannerUrl: string;
+    storage: 'LOCAL' | 'R2';
     /**
      * Start date of the media (first airing/release)
      */
@@ -754,19 +788,18 @@ export type Media = {
      * End date of the media (last airing/release)
      */
     endDate?: string;
-    category: Category;
     /**
-     * Total number of subtitle segments available
+     * Media category
      */
-    segmentCount?: number;
+    category: 'ANIME' | 'JDRAMA';
     /**
-     * Total number of episodes available
+     * Version of the media-sub-splitter used
      */
-    episodeCount?: number;
+    version: string;
     /**
-     * Version identifier for the media entry
+     * Hash salt used when generating the hash for the related media assets
      */
-    version: string;
+    hashSalt: string;
     /**
      * Animation studio that produced the media
      */
@@ -784,181 +817,22 @@ export type Media = {
      */
     storageBasePath?: string;
     /**
-     * Characters appearing in the media with their voice actors
-     */
-    characters?: Array<MediaCharacter>;
-    /**
-     * Lists that contain this media
-     */
-    lists?: Array<List>;
-};
-export type MediaListResponse = {
-    data: Array<Media>;
-    /**
-     * Next cursor for pagination (undefined if no more results)
-     */
-    cursor?: number;
-    /**
-     * Whether more results are available
+     * List of characters appearing in the media with their voice actors
      */
-    hasMoreResults: boolean;
+    characters?: Array<CharacterInput>;
 };
 /**
- * Character data for creating/updating media
+ * Conflict error response
  */
-export type CharacterInput = {
+export type Error409 = {
     /**
-     * AniList character ID
+     * Specific error code for programmatic handling
      */
-    id: number;
+    code: 'ACCOUNT_CONFLICT' | 'DUPLICATE_KEY';
     /**
-     * Japanese name of the character
+     * A short, human-readable summary of the problem
      */
-    nameJa: string;
-    /**
-     * English name of the character
-     */
-    nameEn: string;
-    /**
-     * Character image URL
-     */
-    imageUrl: string;
-    /**
-     * 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;
-};
-/**
- * List data for adding media to a list
- */
-export type ListInput = {
-    /**
-     * Existing list ID (if adding to existing list)
-     */
-    listId?: number;
-    /**
-     * Name for new list (if creating new list)
-     */
-    listName?: string;
-    /**
-     * Type of list (if creating new list)
-     */
-    listType?: 'SERIES' | 'CUSTOM';
-    /**
-     * Visibility of list (if creating new list)
-     */
-    listVisibility?: 'PUBLIC' | 'PRIVATE';
-    /**
-     * Position/order of media in the list (1-indexed)
-     */
-    position: number;
-};
-/**
- * Request body for creating a new media entry
- */
-export type MediaCreateRequest = {
-    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>;
-    /**
-     * Lists to add this media to (e.g., series, franchise)
-     */
-    lists?: Array<ListInput>;
-};
-/**
- * Conflict error response
- */
-export type Error409 = {
-    /**
-     * Specific error code for programmatic handling
-     */
-    code: 'ACCOUNT_CONFLICT' | 'DUPLICATE_KEY';
-    /**
-     * A short, human-readable summary of the problem
-     */
-    title: string;
+    title: string;
     /**
      * A human-readable explanation specific to this occurrence
      */
@@ -1090,10 +964,6 @@ export type MediaUpdateRequest = {
      * List of characters appearing in the media with their voice actors
      */
     characters?: Array<CharacterInput>;
-    /**
-     * Lists to add this media to (e.g., series, franchise)
-     */
-    lists?: Array<ListInput>;
     /**
      * Total number of subtitle segments available
      */
@@ -1145,15 +1015,8 @@ export type EpisodeListResponse = {
     /**
      * Array of episode objects
      */
-    data: Array<Episode>;
-    /**
-     * Cursor for pagination (last episode number in current page)
-     */
-    cursor?: number;
-    /**
-     * Whether more results are available
-     */
-    hasMore: boolean;
+    episodes: Array<Episode>;
+    pagination: CursorPagination;
 };
 export type EpisodeCreateRequest = {
     /**
@@ -1222,111 +1085,6 @@ export type EpisodeUpdateRequest = {
      */
     thumbnailUrl?: string;
 };
-/**
- * Japanese content with optional character count
- */
-export type JapaneseContent = {
-    /**
-     * Original Japanese content
-     */
-    content: string;
-    /**
-     * Number of characters in the Japanese content
-     */
-    characterCount?: number;
-};
-/**
- * Translation content for a language
- */
-export type TranslationContent = {
-    /**
-     * Translated content
-     */
-    content?: string;
-    /**
-     * Whether the translation was machine-translated
-     */
-    isMachineTranslated: boolean;
-};
-export type Segment = {
-    /**
-     * Auto-generated segment ID
-     */
-    id: number;
-    /**
-     * Unique identifier for the segment
-     */
-    uuid: string;
-    /**
-     * Position of the segment within the episode
-     */
-    position: number;
-    /**
-     * Segment status
-     */
-    status: 'DELETED' | 'ACTIVE' | 'SUSPENDED' | 'VERIFIED' | 'INVALID' | 'TOO_LONG';
-    /**
-     * Timestamp in H:MM:SS.ffffff format indicating when the segment starts
-     */
-    startTime: string;
-    /**
-     * Timestamp in H:MM:SS.ffffff format indicating when the segment ends
-     */
-    endTime: string;
-    textJa: JapaneseContent;
-    textEn: TranslationContent;
-    textEs: TranslationContent;
-    /**
-     * Whether the segment contains NSFW content
-     */
-    isNsfw: boolean;
-    /**
-     * URL to segment screenshot/image (generated from storage + hashedId)
-     */
-    imageUrl?: string;
-    /**
-     * URL to segment audio file (generated from storage + hashedId)
-     */
-    audioUrl?: string;
-    /**
-     * URL to segment video file (generated from storage + hashedId)
-     */
-    videoUrl?: string;
-    /**
-     * Episode number this segment belongs to
-     */
-    episode: number;
-    /**
-     * Media ID this segment belongs to
-     */
-    mediaId: number;
-    /**
-     * Storage backend for segment assets
-     */
-    storage: 'LOCAL' | 'R2';
-    /**
-     * Hash identifier for the segment
-     */
-    hashedId: string;
-    /**
-     * Morphological analysis of the Japanese content
-     */
-    morphemes?: Array<Morpheme>;
-};
-export type SegmentListResponse = {
-    /**
-     * Array of segment objects
-     */
-    data: Array<Segment>;
-    /**
-     * Cursor for pagination (last segment ID in current page)
-     */
-    cursor?: number;
-    /**
-     * Whether more results are available
-     */
-    hasMore: boolean;
-};
 export type SegmentCreateRequest = {
     /**
      * Position of the segment within the episode
@@ -1337,13 +1095,13 @@ export type SegmentCreateRequest = {
      */
     status?: 'DELETED' | 'ACTIVE' | 'SUSPENDED' | 'VERIFIED' | 'INVALID' | 'TOO_LONG';
     /**
-     * Timestamp in H:MM:SS.ffffff format indicating when the segment starts
+     * Start time of the segment in milliseconds from the beginning of the episode
      */
-    startTime: string;
+    startTimeMs: number;
     /**
-     * Timestamp in H:MM:SS.ffffff format indicating when the segment ends
+     * End time of the segment in milliseconds from the beginning of the episode
      */
-    endTime: string;
+    endTimeMs: number;
     textJa: {
         /**
          * Original Japanese content of the segment
@@ -1370,10 +1128,19 @@ export type SegmentCreateRequest = {
          */
         isMachineTranslated?: boolean;
     };
+    contentRating?: ContentRating;
     /**
-     * Whether the segment contains NSFW content
+     * Raw WD Tagger v3 classifier output used to derive content rating
      */
-    isNsfw?: boolean;
+    ratingAnalysis?: {
+        [key: string]: unknown;
+    };
+    /**
+     * POS tokenization results keyed by engine (sudachi, unidic)
+     */
+    posAnalysis?: {
+        [key: string]: unknown;
+    };
     /**
      * Storage backend for segment assets
      */
@@ -1383,6 +1150,35 @@ 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
  */
@@ -1396,13 +1192,13 @@ export type SegmentUpdateRequest = {
      */
     status?: 'DELETED' | 'ACTIVE' | 'SUSPENDED' | 'VERIFIED' | 'INVALID' | 'TOO_LONG';
     /**
-     * Timestamp in H:MM:SS.ffffff format indicating when the segment starts
+     * Start time of the segment in milliseconds from the beginning of the episode
      */
-    startTime?: string;
+    startTimeMs?: number;
     /**
-     * Timestamp in H:MM:SS.ffffff format indicating when the segment ends
+     * End time of the segment in milliseconds from the beginning of the episode
      */
-    endTime?: string;
+    endTimeMs?: number;
     textJa?: {
         /**
          * Original Japanese content of the segment
@@ -1429,10 +1225,19 @@ export type SegmentUpdateRequest = {
          */
         isMachineTranslated?: boolean;
     };
+    contentRating?: ContentRating;
+    /**
+     * Raw WD Tagger v3 classifier output used to derive content rating
+     */
+    ratingAnalysis?: {
+        [key: string]: unknown;
+    };
     /**
-     * Whether the segment contains NSFW content
+     * POS tokenization results keyed by engine (sudachi, unidic)
      */
-    isNsfw?: boolean;
+    posAnalysis?: {
+        [key: string]: unknown;
+    };
     /**
      * Storage backend for segment assets
      */
@@ -1443,31 +1248,100 @@ export type SegmentUpdateRequest = {
     hashedId?: string;
 };
 export type SegmentContextResponse = {
-    segments: Array<SearchResult>;
+    segments: Array<Segment>;
+    includes?: {
+        /**
+         * Media objects keyed by mediaId
+         */
+        media?: {
+            [key: string]: Media;
+        };
+    };
 };
 /**
- * Character with all media appearances
+ * Ordered media series grouping
  */
-export type CharacterWithMedia = {
+export type Series = {
     /**
-     * AniList character ID
+     * Series ID
      */
     id: number;
     /**
-     * Japanese name of the character
+     * Japanese name of the series
      */
     nameJa: string;
     /**
-     * English name of the character
+     * Romaji name of the series
      */
-    nameEn: string;
+    nameRomaji: string;
     /**
-     * Character image URL
+     * English name of the series
      */
-    imageUrl: string;
-    seiyuu: Seiyuu;
-    /**
-     * All media this character appears in
+    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;
@@ -1478,7 +1352,7 @@ export type CharacterWithMedia = {
     }>;
 };
 /**
- * Seiyuu with all voice acting roles
+ * Seiyuu details with optional character appearances
  */
 export type SeiyuuWithRoles = {
     /**
@@ -1498,15 +1372,14 @@ export type SeiyuuWithRoles = {
      */
     imageUrl: string;
     /**
-     * All characters voiced by this seiyuu with their media appearances
+     * Characters voiced by this seiyuu with their media appearances
      */
-    roles: Array<{
-        character?: Character;
-        media?: Media;
+    characters: Array<Character & {
+        media: Media;
         /**
          * Character role in this media
          */
-        role?: 'MAIN' | 'SUPPORTING' | 'BACKGROUND';
+        role: 'MAIN' | 'SUPPORTING' | 'BACKGROUND';
     }>;
 };
 export type UserQuotaResponse = {
@@ -1535,31 +1408,65 @@ export type UserQuotaResponse = {
      */
     periodEnd: string;
 };
-export type Report = {
+export type ReportTargetMedia = {
     /**
-     * Report ID
+     * Report target type
      */
-    id: number;
+    type: 'MEDIA';
     /**
-     * Who created this report
+     * Media ID this report targets
      */
-    source: 'USER' | 'AUTO';
+    mediaId: number;
+};
+export type ReportTargetEpisode = {
     /**
-     * What level the report targets
+     * Report target type
      */
-    targetType: 'SEGMENT' | 'EPISODE' | 'MEDIA';
+    type: 'EPISODE';
     /**
      * Media ID this report targets
      */
-    targetMediaId: number;
+    mediaId: number;
     /**
-     * Episode number (for EPISODE/SEGMENT targets)
+     * Episode number this report targets
      */
-    targetEpisodeNumber?: number;
+    episodeNumber: number;
+};
+export type ReportTargetSegment = {
+    /**
+     * Report target type
+     */
+    type: 'SEGMENT';
+    /**
+     * Media ID this report targets
+     */
+    mediaId: number;
+    /**
+     * Episode number containing the segment
+     */
+    episodeNumber?: number;
+    /**
+     * Segment UUID this report targets
+     */
+    segmentUuid: string;
+};
+export type ReportTarget = ({
+    type: 'MEDIA';
+} & ReportTargetMedia) | ({
+    type: 'EPISODE';
+} & ReportTargetEpisode) | ({
+    type: 'SEGMENT';
+} & ReportTargetSegment);
+export type Report = {
+    /**
+     * Report ID
+     */
+    id: number;
     /**
-     * Segment UUID (for SEGMENT targets)
+     * Who created this report
      */
-    targetSegmentUuid?: string;
+    source: 'USER' | 'AUTO';
+    target: ReportTarget;
     /**
      * ID of the auto-check run that created this report (AUTO only)
      */
@@ -1600,29 +1507,16 @@ export type Report = {
     updatedAt?: string;
 };
 export type ReportListResponse = {
-    data: Array<Report>;
-    /**
-     * Whether more results are available
-     */
-    hasMore: boolean;
-    /**
-     * Cursor for next page
-     */
-    cursor?: number;
-};
+    reports: Array<Report>;
+    pagination: CursorPagination;
+};
+export type UserReportTarget = ({
+    type: 'MEDIA';
+} & ReportTargetMedia) | ({
+    type: 'SEGMENT';
+} & ReportTargetSegment);
 export type CreateReportRequest = {
-    /**
-     * Type of the entity being reported
-     */
-    targetType: 'SEGMENT' | 'MEDIA';
-    /**
-     * Media ID of the reported entity
-     */
-    targetMediaId: number;
-    /**
-     * Segment UUID (required when targetType is SEGMENT)
-     */
-    targetSegmentUuid?: string;
+    target: UserReportTarget;
     /**
      * Reason for the report
      */
@@ -1643,12 +1537,44 @@ export type UserPreferences = {
      * Preferred language for media names display
      */
     mediaNameLanguage?: 'english' | 'japanese' | 'romaji';
+    /**
+     * Per-category content rating display preferences
+     */
+    contentRatingPreferences?: {
+        suggestive?: 'show' | 'blur' | 'hide';
+        explicit?: 'show' | 'blur' | 'hide';
+    };
     searchHistory?: {
         /**
          * Whether activity tracking is enabled (default true)
          */
         enabled?: boolean;
     };
+    /**
+     * ISO timestamp of when the user last visited the blog page
+     */
+    blogLastVisited?: string;
+    ankiProfiles?: Array<{
+        id: string;
+        name: string;
+        deck?: string;
+        model?: string;
+        fields?: Array<{
+            key: string;
+            value: string;
+        }>;
+        key?: string;
+        serverAddress: string;
+    }>;
+    /**
+     * Media hidden from search results by the user
+     */
+    hiddenMedia?: Array<{
+        mediaId: number;
+        nameEn?: string;
+        nameJa?: string;
+        nameRomaji?: string;
+    }>;
 };
 /**
  * Type of user activity
@@ -1662,102 +1588,108 @@ export type UserActivity = {
     searchQuery?: string;
     createdAt: string;
 };
-export type LabFeature = {
+/**
+ * User segment collection
+ */
+export type Collection = {
     /**
-     * Unique identifier for the lab feature
+     * Collection ID
      */
-    key: string;
+    id: number;
     /**
-     * Human-readable feature name
+     * Name of the collection
      */
     name: string;
     /**
-     * Description of what the feature does
+     * User ID who owns the collection
      */
-    description: string;
+    userId: number;
     /**
-     * Whether the feature is globally available
+     * Visibility of the collection
      */
-    enabled: boolean;
+    visibility: 'PUBLIC' | 'PRIVATE';
+};
+export type UserExportCollection = Collection & {
+    /**
+     * Segment UUIDs in saved order
+     */
+    segmentUuids: Array<string>;
 };
 /**
- * Request body for creating a new standalone list
+ * User data export payload (identifier-oriented references)
  */
-export type ListCreateRequest = {
+export type UserExportResponse = {
+    profile: {
+        id: number;
+        username: string;
+        email: string;
+        createdAt: string;
+    };
+    preferences: UserPreferences;
+    activity: Array<UserActivity>;
+    collections: Array<UserExportCollection>;
+    reports: Array<Report>;
+};
+export type UserLabFeature = {
+    /**
+     * Unique identifier for the lab feature
+     */
+    key: string;
     /**
-     * Name of the list
+     * Human-readable feature name
      */
     name: string;
     /**
-     * Type of list
+     * Description of what the feature does
      */
-    type?: 'SERIES' | 'CUSTOM' | 'SEGMENT';
+    description: string;
     /**
-     * User ID who owns the list (1 = admin)
+     * Whether the feature is globally available
      */
-    userId?: number;
+    enabled: boolean;
     /**
-     * Visibility of the list
+     * Whether the user has opted in to this feature
      */
-    visibility?: 'PUBLIC' | 'PRIVATE';
+    userEnabled: boolean;
 };
 /**
- * List with all media in order
+ * Paginated collection list response
  */
-export type ListWithMedia = {
-    /**
-     * List ID
-     */
-    id: number;
+export type CollectionListResponse = {
+    collections: Array<Collection>;
+    pagination: CursorPagination;
+};
+/**
+ * Request body for creating a new collection
+ */
+export type CollectionRequests = {
     /**
-     * Name of the list
+     * Name of the collection
      */
     name: string;
     /**
-     * Type of list
-     */
-    type: 'SERIES' | 'CUSTOM' | 'SEGMENT';
-    /**
-     * User ID who owns the list (1 = admin)
+     * Visibility of the collection
      */
-    userId: number;
-    /**
-     * Visibility of the list
-     */
-    visibility: 'PUBLIC' | 'PRIVATE';
-    /**
-     * All media in the list, sorted by position
-     */
-    media: Array<{
-        /**
-         * Position in the list (1-indexed)
-         */
-        position?: number;
-        media?: Media;
-    }>;
+    visibility?: 'PUBLIC' | 'PRIVATE';
 };
 /**
- * List with saved segments (search result format)
+ * Collection with saved segments (search result format)
  */
-export type ListWithSegments = {
+export type CollectionWithSegments = {
     /**
-     * List ID
+     * Collection ID
      */
     id: number;
     /**
-     * Name of the list
+     * Name of the collection
      */
     name: string;
     /**
-     * Type of list
-     */
-    type: 'SERIES' | 'CUSTOM' | 'SEGMENT';
-    /**
-     * User ID who owns the list
+     * User ID who owns the collection
      */
     userId: number;
     /**
-     * Visibility of the list
+     * Visibility of the collection
      */
     visibility: 'PUBLIC' | 'PRIVATE';
     /**
@@ -1765,19 +1697,28 @@ export type ListWithSegments = {
      */
     segments: Array<{
         /**
-         * Position in the list
+         * Position in the collection
          */
         position?: number;
         /**
          * User annotation
          */
         note?: string;
-        result?: SearchResult;
+        result?: Segment;
     }>;
+    includes?: {
+        /**
+         * Media objects keyed by mediaId
+         */
+        media?: {
+            [key: string]: Media;
+        };
+    };
     /**
-     * Total number of segments in the list
+     * Total number of segments in the collection
      */
     totalCount: number;
+    pagination: CursorPagination;
 };
 /**
  * Request to reindex segments from the database into Elasticsearch
@@ -1858,15 +1799,8 @@ export type AdminReport = Report & {
     reporterName: string;
 };
 export type AdminReportListResponse = {
-    data: Array<AdminReport>;
-    /**
-     * Whether more results are available
-     */
-    hasMore: boolean;
-    /**
-     * Cursor for next page
-     */
-    cursor?: number;
+    reports: Array<AdminReport>;
+    pagination: CursorPagination;
 };
 export type UpdateReportRequest = {
     /**
@@ -2013,13 +1947,322 @@ export type ReviewAllowlist = {
      */
     createdAt: string;
 };
-export type HealthCheckData = {
-    body?: never;
-    path?: never;
+export type SearchData = {
+    body?: SearchRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/search';
+};
+export type SearchErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type SearchError = SearchErrors[keyof SearchErrors];
+export type SearchResponses = {
+    /**
+     * OK
+     */
+    200: SearchResponse;
+};
+export type SearchResponse2 = SearchResponses[keyof SearchResponses];
+export type GetSearchStatsData = {
+    body?: SearchStatsRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/search/stats';
+};
+export type GetSearchStatsErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type GetSearchStatsError = GetSearchStatsErrors[keyof GetSearchStatsErrors];
+export type GetSearchStatsResponses = {
+    /**
+     * OK
+     */
+    200: SearchStatsResponse;
+};
+export type GetSearchStatsResponse = GetSearchStatsResponses[keyof GetSearchStatsResponses];
+export type SearchWordsData = {
+    body: SearchMultipleRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/search/words';
+};
+export type SearchWordsErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type SearchWordsError = SearchWordsErrors[keyof SearchWordsErrors];
+export type SearchWordsResponses = {
+    /**
+     * OK
+     */
+    200: SearchMultipleResponse;
+};
+export type SearchWordsResponse = SearchWordsResponses[keyof SearchWordsResponses];
+export type ListMediaData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Number of results per page
+         */
+        limit?: number;
+        /**
+         * Pagination cursor offset
+         */
+        cursor?: number;
+        /**
+         * Filter by media category
+         */
+        category?: 'ANIME' | 'JDRAMA';
+        /**
+         * Search query for filtering media by name
+         */
+        query?: string;
+        /**
+         * Resources to expand in the media response (`media.characters` implies `media`)
+         */
+        include?: Array<MediaIncludeExpansion>;
+    };
+    url: '/v1/media';
+};
+export type ListMediaErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    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
+     */
+    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 DeleteMediaData = {
+    body?: never;
+    path: {
+        /**
+         * Media ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/media/{id}';
+};
+export type DeleteMediaErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type DeleteMediaError = DeleteMediaErrors[keyof DeleteMediaErrors];
+export type DeleteMediaResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type DeleteMediaResponse = DeleteMediaResponses[keyof DeleteMediaResponses];
+export type GetMediaData = {
+    body?: never;
+    path: {
+        /**
+         * Media ID
+         */
+        id: number;
+    };
+    query?: {
+        /**
+         * Resources to expand in the media response (`media.characters` implies `media`)
+         */
+        include?: Array<MediaIncludeExpansion>;
+    };
+    url: '/v1/media/{id}';
+};
+export type GetMediaErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type GetMediaError = GetMediaErrors[keyof GetMediaErrors];
+export type GetMediaResponses = {
+    /**
+     * OK
+     */
+    200: Media;
+};
+export type GetMediaResponse = GetMediaResponses[keyof GetMediaResponses];
+export type UpdateMediaData = {
+    body: MediaUpdateRequest;
+    path: {
+        /**
+         * Media ID
+         */
+        id: number;
+    };
     query?: never;
-    url: '/v1/health';
+    url: '/v1/media/{id}';
 };
-export type HealthCheckErrors = {
+export type UpdateMediaErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
     /**
      * Unauthorized
      */
@@ -2028,6 +2271,10 @@ export type HealthCheckErrors = {
      * Forbidden
      */
     403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
     /**
      * Too Many Requests
      */
@@ -2037,21 +2284,35 @@ export type HealthCheckErrors = {
      */
     500: Error500;
 };
-export type HealthCheckError = HealthCheckErrors[keyof HealthCheckErrors];
-export type HealthCheckResponses = {
+export type UpdateMediaError = UpdateMediaErrors[keyof UpdateMediaErrors];
+export type UpdateMediaResponses = {
     /**
      * OK
      */
-    200: SearchHealthCheckResponse;
+    200: Media;
 };
-export type HealthCheckResponse = HealthCheckResponses[keyof HealthCheckResponses];
-export type SearchIndexData = {
-    body?: SearchRequest;
-    path?: never;
-    query?: never;
-    url: '/v1/search';
+export type UpdateMediaResponse = UpdateMediaResponses[keyof UpdateMediaResponses];
+export type ListEpisodesData = {
+    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)
+         */
+        cursor?: number;
+    };
+    url: '/v1/media/{mediaId}/episodes';
 };
-export type SearchIndexErrors = {
+export type ListEpisodesErrors = {
     /**
      * Bad Request
      */
@@ -2064,6 +2325,10 @@ export type SearchIndexErrors = {
      * Forbidden
      */
     403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
     /**
      * Too Many Requests
      */
@@ -2073,21 +2338,26 @@ export type SearchIndexErrors = {
      */
     500: Error500;
 };
-export type SearchIndexError = SearchIndexErrors[keyof SearchIndexErrors];
-export type SearchIndexResponses = {
+export type ListEpisodesError = ListEpisodesErrors[keyof ListEpisodesErrors];
+export type ListEpisodesResponses = {
     /**
-     * OK
+     * Paginated list of episodes
      */
-    200: SearchResponse;
+    200: EpisodeListResponse;
 };
-export type SearchIndexResponse = SearchIndexResponses[keyof SearchIndexResponses];
-export type SearchStatsData = {
-    body?: SearchStatsRequest;
-    path?: never;
+export type ListEpisodesResponse = ListEpisodesResponses[keyof ListEpisodesResponses];
+export type CreateEpisodeData = {
+    body: EpisodeCreateRequest;
+    path: {
+        /**
+         * ID of the media
+         */
+        mediaId: number;
+    };
     query?: never;
-    url: '/v1/search/stats';
+    url: '/v1/media/{mediaId}/episodes';
 };
-export type SearchStatsErrors = {
+export type CreateEpisodeErrors = {
     /**
      * Bad Request
      */
@@ -2100,6 +2370,14 @@ export type SearchStatsErrors = {
      * Forbidden
      */
     403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Conflict
+     */
+    409: Error409;
     /**
      * Too Many Requests
      */
@@ -2109,21 +2387,30 @@ export type SearchStatsErrors = {
      */
     500: Error500;
 };
-export type SearchStatsError = SearchStatsErrors[keyof SearchStatsErrors];
-export type SearchStatsResponses = {
+export type CreateEpisodeError = CreateEpisodeErrors[keyof CreateEpisodeErrors];
+export type CreateEpisodeResponses = {
     /**
-     * OK
+     * Single episode response
      */
-    200: SearchStatsResponse;
+    201: Episode;
 };
-export type SearchStatsResponse2 = SearchStatsResponses[keyof SearchStatsResponses];
-export type SearchWordsData = {
-    body: SearchMultipleRequest;
-    path?: never;
+export type CreateEpisodeResponse = CreateEpisodeResponses[keyof CreateEpisodeResponses];
+export type DeleteEpisodeData = {
+    body?: never;
+    path: {
+        /**
+         * ID of the media
+         */
+        mediaId: number;
+        /**
+         * Episode number
+         */
+        episodeNumber: number;
+    };
     query?: never;
-    url: '/v1/search/words';
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}';
 };
-export type SearchWordsErrors = {
+export type DeleteEpisodeErrors = {
     /**
      * Bad Request
      */
@@ -2136,6 +2423,10 @@ export type SearchWordsErrors = {
      * Forbidden
      */
     403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
     /**
      * Too Many Requests
      */
@@ -2145,38 +2436,30 @@ export type SearchWordsErrors = {
      */
     500: Error500;
 };
-export type SearchWordsError = SearchWordsErrors[keyof SearchWordsErrors];
-export type SearchWordsResponses = {
+export type DeleteEpisodeError = DeleteEpisodeErrors[keyof DeleteEpisodeErrors];
+export type DeleteEpisodeResponses = {
     /**
-     * OK
+     * Episode successfully deleted
      */
-    200: SearchMultipleResponse;
+    204: void;
 };
-export type SearchWordsResponse = SearchWordsResponses[keyof SearchWordsResponses];
-export type MediaIndexData = {
+export type DeleteEpisodeResponse = DeleteEpisodeResponses[keyof DeleteEpisodeResponses];
+export type GetEpisodeData = {
     body?: never;
-    path?: never;
-    query?: {
-        /**
-         * Number of results per page
-         */
-        limit?: number;
-        /**
-         * Pagination cursor offset
-         */
-        cursor?: number;
+    path: {
         /**
-         * Filter by media category
+         * ID of the media
          */
-        category?: 'ANIME' | 'JDRAMA';
+        mediaId: number;
         /**
-         * Search query for filtering media by name
+         * Episode number
          */
-        query?: string;
+        episodeNumber: number;
     };
-    url: '/v1/media';
+    query?: never;
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}';
 };
-export type MediaIndexErrors = {
+export type GetEpisodeErrors = {
     /**
      * Bad Request
      */
@@ -2189,6 +2472,10 @@ export type MediaIndexErrors = {
      * Forbidden
      */
     403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
     /**
      * Too Many Requests
      */
@@ -2198,21 +2485,30 @@ export type MediaIndexErrors = {
      */
     500: Error500;
 };
-export type MediaIndexError = MediaIndexErrors[keyof MediaIndexErrors];
-export type MediaIndexResponses = {
+export type GetEpisodeError = GetEpisodeErrors[keyof GetEpisodeErrors];
+export type GetEpisodeResponses = {
     /**
-     * OK
+     * Single episode response
      */
-    200: MediaListResponse;
+    200: Episode;
 };
-export type MediaIndexResponse = MediaIndexResponses[keyof MediaIndexResponses];
-export type MediaCreateData = {
-    body: MediaCreateRequest;
-    path?: never;
+export type GetEpisodeResponse = GetEpisodeResponses[keyof GetEpisodeResponses];
+export type UpdateEpisodeData = {
+    body: EpisodeUpdateRequest;
+    path: {
+        /**
+         * ID of the media
+         */
+        mediaId: number;
+        /**
+         * Episode number
+         */
+        episodeNumber: number;
+    };
     query?: never;
-    url: '/v1/media';
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}';
 };
-export type MediaCreateErrors = {
+export type UpdateEpisodeErrors = {
     /**
      * Bad Request
      */
@@ -2226,9 +2522,9 @@ export type MediaCreateErrors = {
      */
     403: Error403;
     /**
-     * Conflict
+     * Not Found
      */
-    409: Error409;
+    404: Error404;
     /**
      * Too Many Requests
      */
@@ -2238,26 +2534,39 @@ export type MediaCreateErrors = {
      */
     500: Error500;
 };
-export type MediaCreateError = MediaCreateErrors[keyof MediaCreateErrors];
-export type MediaCreateResponses = {
+export type UpdateEpisodeError = UpdateEpisodeErrors[keyof UpdateEpisodeErrors];
+export type UpdateEpisodeResponses = {
     /**
-     * Created
+     * Single episode response
      */
-    201: Media;
+    200: Episode;
 };
-export type MediaCreateResponse = MediaCreateResponses[keyof MediaCreateResponses];
-export type MediaDestroyData = {
+export type UpdateEpisodeResponse = UpdateEpisodeResponses[keyof UpdateEpisodeResponses];
+export type ListSegmentsData = {
     body?: never;
     path: {
         /**
-         * Media ID
+         * ID of the media
          */
-        id: number;
+        mediaId: number;
+        /**
+         * Episode number
+         */
+        episodeNumber: number;
     };
-    query?: never;
-    url: '/v1/media/{id}';
+    query?: {
+        /**
+         * Maximum number of segments to return
+         */
+        limit?: number;
+        /**
+         * Segment ID to start from (for pagination)
+         */
+        cursor?: number;
+    };
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments';
 };
-export type MediaDestroyErrors = {
+export type ListSegmentsErrors = {
     /**
      * Bad Request
      */
@@ -2283,29 +2592,36 @@ export type MediaDestroyErrors = {
      */
     500: Error500;
 };
-export type MediaDestroyError = MediaDestroyErrors[keyof MediaDestroyErrors];
-export type MediaDestroyResponses = {
+export type ListSegmentsError = ListSegmentsErrors[keyof ListSegmentsErrors];
+export type ListSegmentsResponses = {
     /**
-     * OK
+     * Paginated segment list response
      */
     200: {
-        message?: string;
-        id?: number;
+        /**
+         * Array of segment objects
+         */
+        segments: Array<Segment>;
+        pagination: CursorPagination;
     };
 };
-export type MediaDestroyResponse = MediaDestroyResponses[keyof MediaDestroyResponses];
-export type MediaShowData = {
-    body?: never;
+export type ListSegmentsResponse = ListSegmentsResponses[keyof ListSegmentsResponses];
+export type CreateSegmentData = {
+    body: SegmentCreateRequest;
     path: {
         /**
-         * Media ID
+         * ID of the media
          */
-        id: number;
+        mediaId: number;
+        /**
+         * Episode number
+         */
+        episodeNumber: number;
     };
     query?: never;
-    url: '/v1/media/{id}';
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments';
 };
-export type MediaShowErrors = {
+export type CreateSegmentErrors = {
     /**
      * Bad Request
      */
@@ -2322,6 +2638,10 @@ export type MediaShowErrors = {
      * Not Found
      */
     404: Error404;
+    /**
+     * Conflict
+     */
+    409: Error409;
     /**
      * Too Many Requests
      */
@@ -2331,26 +2651,34 @@ export type MediaShowErrors = {
      */
     500: Error500;
 };
-export type MediaShowError = MediaShowErrors[keyof MediaShowErrors];
-export type MediaShowResponses = {
+export type CreateSegmentError = CreateSegmentErrors[keyof CreateSegmentErrors];
+export type CreateSegmentResponses = {
     /**
-     * OK
+     * Single segment response with internal fields
      */
-    200: Media;
+    201: SegmentInternal;
 };
-export type MediaShowResponse = MediaShowResponses[keyof MediaShowResponses];
-export type MediaUpdateData = {
-    body: MediaUpdateRequest;
+export type CreateSegmentResponse = CreateSegmentResponses[keyof CreateSegmentResponses];
+export type DeleteSegmentData = {
+    body?: never;
     path: {
         /**
-         * Media ID
+         * ID of the media
+         */
+        mediaId: number;
+        /**
+         * Episode number
+         */
+        episodeNumber: number;
+        /**
+         * Segment ID
          */
         id: number;
     };
     query?: never;
-    url: '/v1/media/{id}';
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments/{id}';
 };
-export type MediaUpdateErrors = {
+export type DeleteSegmentErrors = {
     /**
      * Bad Request
      */
@@ -2376,35 +2704,34 @@ export type MediaUpdateErrors = {
      */
     500: Error500;
 };
-export type MediaUpdateError = MediaUpdateErrors[keyof MediaUpdateErrors];
-export type MediaUpdateResponses = {
+export type DeleteSegmentError = DeleteSegmentErrors[keyof DeleteSegmentErrors];
+export type DeleteSegmentResponses = {
     /**
-     * OK
+     * Segment successfully deleted
      */
-    200: Media;
+    204: void;
 };
-export type MediaUpdateResponse = MediaUpdateResponses[keyof MediaUpdateResponses];
-export type EpisodeIndexData = {
+export type DeleteSegmentResponse = DeleteSegmentResponses[keyof DeleteSegmentResponses];
+export type GetSegmentData = {
     body?: never;
     path: {
         /**
          * ID of the media
          */
         mediaId: number;
-    };
-    query?: {
         /**
-         * Maximum number of episodes to return
+         * Episode number
          */
-        size?: number;
+        episodeNumber: number;
         /**
-         * Episode number to start from (for pagination)
+         * Segment ID
          */
-        cursor?: number;
+        id: number;
     };
-    url: '/v1/media/{mediaId}/episodes';
+    query?: never;
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments/{id}';
 };
-export type EpisodeIndexErrors = {
+export type GetSegmentErrors = {
     /**
      * Bad Request
      */
@@ -2430,26 +2757,34 @@ export type EpisodeIndexErrors = {
      */
     500: Error500;
 };
-export type EpisodeIndexError = EpisodeIndexErrors[keyof EpisodeIndexErrors];
-export type EpisodeIndexResponses = {
+export type GetSegmentError = GetSegmentErrors[keyof GetSegmentErrors];
+export type GetSegmentResponses = {
     /**
-     * Paginated list of episodes
+     * Single segment response
      */
-    200: EpisodeListResponse;
+    200: Segment;
 };
-export type EpisodeIndexResponse = EpisodeIndexResponses[keyof EpisodeIndexResponses];
-export type EpisodeCreateData = {
-    body: EpisodeCreateRequest;
+export type GetSegmentResponse = GetSegmentResponses[keyof GetSegmentResponses];
+export type UpdateSegmentData = {
+    body: SegmentUpdateRequest;
     path: {
         /**
          * ID of the media
          */
         mediaId: number;
+        /**
+         * Episode number
+         */
+        episodeNumber: number;
+        /**
+         * Segment ID
+         */
+        id: number;
     };
     query?: never;
-    url: '/v1/media/{mediaId}/episodes';
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments/{id}';
 };
-export type EpisodeCreateErrors = {
+export type UpdateSegmentErrors = {
     /**
      * Bad Request
      */
@@ -2466,10 +2801,6 @@ export type EpisodeCreateErrors = {
      * Not Found
      */
     404: Error404;
-    /**
-     * Conflict
-     */
-    409: Error409;
     /**
      * Too Many Requests
      */
@@ -2479,30 +2810,26 @@ export type EpisodeCreateErrors = {
      */
     500: Error500;
 };
-export type EpisodeCreateError = EpisodeCreateErrors[keyof EpisodeCreateErrors];
-export type EpisodeCreateResponses = {
+export type UpdateSegmentError = UpdateSegmentErrors[keyof UpdateSegmentErrors];
+export type UpdateSegmentResponses = {
     /**
-     * Single episode response
+     * Single segment response with internal fields
      */
-    201: Episode;
+    200: SegmentInternal;
 };
-export type EpisodeCreateResponse = EpisodeCreateResponses[keyof EpisodeCreateResponses];
-export type EpisodeDestroyData = {
-    body?: never;
-    path: {
-        /**
-         * ID of the media
-         */
-        mediaId: number;
+export type UpdateSegmentResponse = UpdateSegmentResponses[keyof UpdateSegmentResponses];
+export type GetSegmentByUuidData = {
+    body?: never;
+    path: {
         /**
-         * Episode number
+         * Segment UUID
          */
-        episodeNumber: number;
+        uuid: string;
     };
     query?: never;
-    url: '/v1/media/{mediaId}/episodes/{episodeNumber}';
+    url: '/v1/media/segments/{uuid}';
 };
-export type EpisodeDestroyErrors = {
+export type GetSegmentByUuidErrors = {
     /**
      * Bad Request
      */
@@ -2528,30 +2855,36 @@ export type EpisodeDestroyErrors = {
      */
     500: Error500;
 };
-export type EpisodeDestroyError = EpisodeDestroyErrors[keyof EpisodeDestroyErrors];
-export type EpisodeDestroyResponses = {
-    /**
-     * Episode successfully deleted
-     */
-    204: void;
+export type GetSegmentByUuidError = GetSegmentByUuidErrors[keyof GetSegmentByUuidErrors];
+export type GetSegmentByUuidResponses = {
+    200: Segment;
 };
-export type EpisodeDestroyResponse = EpisodeDestroyResponses[keyof EpisodeDestroyResponses];
-export type EpisodeShowData = {
+export type GetSegmentByUuidResponse = GetSegmentByUuidResponses[keyof GetSegmentByUuidResponses];
+export type GetSegmentContextData = {
     body?: never;
     path: {
         /**
-         * ID of the media
+         * Segment UUID
          */
-        mediaId: number;
+        uuid: string;
+    };
+    query?: {
         /**
-         * Episode number
+         * Number of segments to return before and after the target
          */
-        episodeNumber: number;
+        limit?: number;
+        /**
+         * Content ratings to include (omit for all ratings)
+         */
+        contentRating?: Array<ContentRating>;
+        /**
+         * Resources to expand in the response includes block
+         */
+        include?: Array<IncludeExpansion>;
     };
-    query?: never;
-    url: '/v1/media/{mediaId}/episodes/{episodeNumber}';
+    url: '/v1/media/segments/{uuid}/context';
 };
-export type EpisodeShowErrors = {
+export type GetSegmentContextErrors = {
     /**
      * Bad Request
      */
@@ -2577,30 +2910,34 @@ export type EpisodeShowErrors = {
      */
     500: Error500;
 };
-export type EpisodeShowError = EpisodeShowErrors[keyof EpisodeShowErrors];
-export type EpisodeShowResponses = {
+export type GetSegmentContextError = GetSegmentContextErrors[keyof GetSegmentContextErrors];
+export type GetSegmentContextResponses = {
     /**
-     * Single episode response
+     * OK
      */
-    200: Episode;
+    200: SegmentContextResponse;
 };
-export type EpisodeShowResponse = EpisodeShowResponses[keyof EpisodeShowResponses];
-export type EpisodeUpdateData = {
-    body: EpisodeUpdateRequest;
-    path: {
+export type GetSegmentContextResponse = GetSegmentContextResponses[keyof GetSegmentContextResponses];
+export type ListSeriesData = {
+    body?: never;
+    path?: never;
+    query?: {
         /**
-         * ID of the media
+         * Number of results per page
          */
-        mediaId: number;
+        limit?: number;
         /**
-         * Episode number
+         * Pagination cursor offset
          */
-        episodeNumber: number;
+        cursor?: number;
+        /**
+         * Case-insensitive search across English, Japanese, and Romaji names
+         */
+        query?: string;
     };
-    query?: never;
-    url: '/v1/media/{mediaId}/episodes/{episodeNumber}';
+    url: '/v1/media/series';
 };
-export type EpisodeUpdateErrors = {
+export type ListSeriesErrors = {
     /**
      * Bad Request
      */
@@ -2613,10 +2950,6 @@ export type EpisodeUpdateErrors = {
      * Forbidden
      */
     403: Error403;
-    /**
-     * Not Found
-     */
-    404: Error404;
     /**
      * Too Many Requests
      */
@@ -2626,39 +2959,34 @@ export type EpisodeUpdateErrors = {
      */
     500: Error500;
 };
-export type EpisodeUpdateError = EpisodeUpdateErrors[keyof EpisodeUpdateErrors];
-export type EpisodeUpdateResponses = {
+export type ListSeriesError = ListSeriesErrors[keyof ListSeriesErrors];
+export type ListSeriesResponses = {
     /**
-     * Single episode response
+     * OK
      */
-    200: Episode;
+    200: SeriesListResponse;
 };
-export type EpisodeUpdateResponse = EpisodeUpdateResponses[keyof EpisodeUpdateResponses];
-export type SegmentIndexData = {
-    body?: never;
-    path: {
-        /**
-         * ID of the media
-         */
-        mediaId: number;
+export type ListSeriesResponse = ListSeriesResponses[keyof ListSeriesResponses];
+export type CreateSeriesData = {
+    body: {
         /**
-         * Episode number
+         * Japanese name of the series
          */
-        episodeNumber: number;
-    };
-    query?: {
+        nameJa: string;
         /**
-         * Maximum number of segments to return
+         * Romaji name of the series
          */
-        size?: number;
+        nameRomaji: string;
         /**
-         * Segment ID to start from (for pagination)
+         * English name of the series
          */
-        cursor?: number;
+        nameEn: string;
     };
-    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments';
+    path?: never;
+    query?: never;
+    url: '/v1/media/series';
 };
-export type SegmentIndexErrors = {
+export type CreateSeriesErrors = {
     /**
      * Bad Request
      */
@@ -2671,10 +2999,6 @@ export type SegmentIndexErrors = {
      * Forbidden
      */
     403: Error403;
-    /**
-     * Not Found
-     */
-    404: Error404;
     /**
      * Too Many Requests
      */
@@ -2684,30 +3008,26 @@ export type SegmentIndexErrors = {
      */
     500: Error500;
 };
-export type SegmentIndexError = SegmentIndexErrors[keyof SegmentIndexErrors];
-export type SegmentIndexResponses = {
+export type CreateSeriesError = CreateSeriesErrors[keyof CreateSeriesErrors];
+export type CreateSeriesResponses = {
     /**
-     * Paginated list of segments
+     * Created
      */
-    200: SegmentListResponse;
+    201: Series;
 };
-export type SegmentIndexResponse = SegmentIndexResponses[keyof SegmentIndexResponses];
-export type SegmentCreateData = {
-    body: SegmentCreateRequest;
+export type CreateSeriesResponse = CreateSeriesResponses[keyof CreateSeriesResponses];
+export type DeleteSeriesData = {
+    body?: never;
     path: {
         /**
-         * ID of the media
-         */
-        mediaId: number;
-        /**
-         * Episode number
+         * Series ID
          */
-        episodeNumber: number;
+        id: number;
     };
     query?: never;
-    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments';
+    url: '/v1/media/series/{id}';
 };
-export type SegmentCreateErrors = {
+export type DeleteSeriesErrors = {
     /**
      * Bad Request
      */
@@ -2724,10 +3044,6 @@ export type SegmentCreateErrors = {
      * Not Found
      */
     404: Error404;
-    /**
-     * Conflict
-     */
-    409: Error409;
     /**
      * Too Many Requests
      */
@@ -2737,34 +3053,31 @@ export type SegmentCreateErrors = {
      */
     500: Error500;
 };
-export type SegmentCreateError = SegmentCreateErrors[keyof SegmentCreateErrors];
-export type SegmentCreateResponses = {
+export type DeleteSeriesError = DeleteSeriesErrors[keyof DeleteSeriesErrors];
+export type DeleteSeriesResponses = {
     /**
-     * Single segment response
+     * No Content
      */
-    201: Segment;
+    204: void;
 };
-export type SegmentCreateResponse = SegmentCreateResponses[keyof SegmentCreateResponses];
-export type SegmentDestroyData = {
+export type DeleteSeriesResponse = DeleteSeriesResponses[keyof DeleteSeriesResponses];
+export type GetSeriesData = {
     body?: never;
     path: {
         /**
-         * ID of the media
-         */
-        mediaId: number;
-        /**
-         * Episode number
+         * Series ID
          */
-        episodeNumber: number;
+        id: number;
+    };
+    query?: {
         /**
-         * Segment ID
+         * Resources to expand in the series response (`media.characters` implies `media`)
          */
-        id: number;
+        include?: Array<MediaIncludeExpansion>;
     };
-    query?: never;
-    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments/{id}';
+    url: '/v1/media/series/{id}';
 };
-export type SegmentDestroyErrors = {
+export type GetSeriesErrors = {
     /**
      * Bad Request
      */
@@ -2790,34 +3103,39 @@ export type SegmentDestroyErrors = {
      */
     500: Error500;
 };
-export type SegmentDestroyError = SegmentDestroyErrors[keyof SegmentDestroyErrors];
-export type SegmentDestroyResponses = {
+export type GetSeriesError = GetSeriesErrors[keyof GetSeriesErrors];
+export type GetSeriesResponses = {
     /**
-     * Segment successfully deleted
+     * OK
      */
-    204: void;
+    200: SeriesWithMedia;
 };
-export type SegmentDestroyResponse = SegmentDestroyResponses[keyof SegmentDestroyResponses];
-export type SegmentShowData = {
-    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;
         /**
-         * Segment ID
+         * Updated English name
+         */
+        nameEn?: string;
+    };
+    path: {
+        /**
+         * Series ID
          */
         id: number;
     };
     query?: never;
-    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments/{id}';
+    url: '/v1/media/series/{id}';
 };
-export type SegmentShowErrors = {
+export type UpdateSeriesErrors = {
     /**
      * Bad Request
      */
@@ -2843,34 +3161,35 @@ export type SegmentShowErrors = {
      */
     500: Error500;
 };
-export type SegmentShowError = SegmentShowErrors[keyof SegmentShowErrors];
-export type SegmentShowResponses = {
+export type UpdateSeriesError = UpdateSeriesErrors[keyof UpdateSeriesErrors];
+export type UpdateSeriesResponses = {
     /**
-     * Single segment response
+     * OK
      */
-    200: Segment;
+    200: Series;
 };
-export type SegmentShowResponse = SegmentShowResponses[keyof SegmentShowResponses];
-export type SegmentUpdateData = {
-    body: SegmentUpdateRequest;
-    path: {
+export type UpdateSeriesResponse = UpdateSeriesResponses[keyof UpdateSeriesResponses];
+export type AddMediaToSeriesData = {
+    body: {
         /**
-         * ID of the media
+         * Media ID to add
          */
         mediaId: number;
         /**
-         * Episode number
+         * Position in the series (1-indexed)
          */
-        episodeNumber: number;
+        position: number;
+    };
+    path: {
         /**
-         * Segment ID
+         * Series ID
          */
         id: number;
     };
     query?: never;
-    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments/{id}';
+    url: '/v1/media/series/{id}/media';
 };
-export type SegmentUpdateErrors = {
+export type AddMediaToSeriesErrors = {
     /**
      * Bad Request
      */
@@ -2896,26 +3215,30 @@ export type SegmentUpdateErrors = {
      */
     500: Error500;
 };
-export type SegmentUpdateError = SegmentUpdateErrors[keyof SegmentUpdateErrors];
-export type SegmentUpdateResponses = {
+export type AddMediaToSeriesError = AddMediaToSeriesErrors[keyof AddMediaToSeriesErrors];
+export type AddMediaToSeriesResponses = {
     /**
-     * Single segment response
+     * No Content
      */
-    200: Segment;
+    204: void;
 };
-export type SegmentUpdateResponse = SegmentUpdateResponses[keyof SegmentUpdateResponses];
-export type SegmentShowByUuidData = {
+export type AddMediaToSeriesResponse = AddMediaToSeriesResponses[keyof AddMediaToSeriesResponses];
+export type RemoveMediaFromSeriesData = {
     body?: never;
     path: {
         /**
-         * Segment UUID
+         * Series ID
          */
-        uuid: string;
+        id: number;
+        /**
+         * Media ID
+         */
+        mediaId: number;
     };
     query?: never;
-    url: '/v1/media/segments/{uuid}';
+    url: '/v1/media/series/{id}/media/{mediaId}';
 };
-export type SegmentShowByUuidErrors = {
+export type RemoveMediaFromSeriesErrors = {
     /**
      * Bad Request
      */
@@ -2941,28 +3264,35 @@ export type SegmentShowByUuidErrors = {
      */
     500: Error500;
 };
-export type SegmentShowByUuidError = SegmentShowByUuidErrors[keyof SegmentShowByUuidErrors];
-export type SegmentShowByUuidResponses = {
-    200: Segment;
+export type RemoveMediaFromSeriesError = RemoveMediaFromSeriesErrors[keyof RemoveMediaFromSeriesErrors];
+export type RemoveMediaFromSeriesResponses = {
+    /**
+     * No Content
+     */
+    204: void;
 };
-export type SegmentShowByUuidResponse = SegmentShowByUuidResponses[keyof SegmentShowByUuidResponses];
-export type SegmentContextShowData = {
-    body?: never;
-    path: {
+export type RemoveMediaFromSeriesResponse = RemoveMediaFromSeriesResponses[keyof RemoveMediaFromSeriesResponses];
+export type UpdateSeriesMediaData = {
+    body: {
         /**
-         * Segment UUID
+         * New position in the series (1-indexed)
          */
-        uuid: string;
+        position: number;
     };
-    query?: {
+    path: {
         /**
-         * Number of segments to return before and after the target
+         * Series ID
          */
-        limit?: number;
+        id: number;
+        /**
+         * Media ID
+         */
+        mediaId: number;
     };
-    url: '/v1/media/segments/{uuid}/context';
+    query?: never;
+    url: '/v1/media/series/{id}/media/{mediaId}';
 };
-export type SegmentContextShowErrors = {
+export type UpdateSeriesMediaErrors = {
     /**
      * Bad Request
      */
@@ -2988,15 +3318,15 @@ export type SegmentContextShowErrors = {
      */
     500: Error500;
 };
-export type SegmentContextShowError = SegmentContextShowErrors[keyof SegmentContextShowErrors];
-export type SegmentContextShowResponses = {
+export type UpdateSeriesMediaError = UpdateSeriesMediaErrors[keyof UpdateSeriesMediaErrors];
+export type UpdateSeriesMediaResponses = {
     /**
-     * OK
+     * No Content
      */
-    200: SegmentContextResponse;
+    204: void;
 };
-export type SegmentContextShowResponse = SegmentContextShowResponses[keyof SegmentContextShowResponses];
-export type CharacterShowData = {
+export type UpdateSeriesMediaResponse = UpdateSeriesMediaResponses[keyof UpdateSeriesMediaResponses];
+export type GetCharacterData = {
     body?: never;
     path: {
         /**
@@ -3007,7 +3337,7 @@ export type CharacterShowData = {
     query?: never;
     url: '/v1/media/characters/{id}';
 };
-export type CharacterShowErrors = {
+export type GetCharacterErrors = {
     /**
      * Bad Request
      */
@@ -3033,15 +3363,15 @@ export type CharacterShowErrors = {
      */
     500: Error500;
 };
-export type CharacterShowError = CharacterShowErrors[keyof CharacterShowErrors];
-export type CharacterShowResponses = {
+export type GetCharacterError = GetCharacterErrors[keyof GetCharacterErrors];
+export type GetCharacterResponses = {
     /**
      * OK
      */
     200: CharacterWithMedia;
 };
-export type CharacterShowResponse = CharacterShowResponses[keyof CharacterShowResponses];
-export type SeiyuuShowData = {
+export type GetCharacterResponse = GetCharacterResponses[keyof GetCharacterResponses];
+export type GetSeiyuuData = {
     body?: never;
     path: {
         /**
@@ -3049,10 +3379,15 @@ export type SeiyuuShowData = {
          */
         id: number;
     };
-    query?: never;
+    query?: {
+        /**
+         * Resources to expand in the response (`character` is included by default)
+         */
+        include?: Array<'character'>;
+    };
     url: '/v1/media/seiyuu/{id}';
 };
-export type SeiyuuShowErrors = {
+export type GetSeiyuuErrors = {
     /**
      * Bad Request
      */
@@ -3078,39 +3413,43 @@ export type SeiyuuShowErrors = {
      */
     500: Error500;
 };
-export type SeiyuuShowError = SeiyuuShowErrors[keyof SeiyuuShowErrors];
-export type SeiyuuShowResponses = {
+export type GetSeiyuuError = GetSeiyuuErrors[keyof GetSeiyuuErrors];
+export type GetSeiyuuResponses = {
     /**
      * OK
      */
     200: SeiyuuWithRoles;
 };
-export type SeiyuuShowResponse = SeiyuuShowResponses[keyof SeiyuuShowResponses];
-export type UserQuotaShowData = {
+export type GetSeiyuuResponse = GetSeiyuuResponses[keyof GetSeiyuuResponses];
+export type GetQuotaData = {
     body?: never;
     path?: never;
     query?: never;
     url: '/v1/user/quota';
 };
-export type UserQuotaShowErrors = {
+export type GetQuotaErrors = {
     /**
      * Unauthorized
      */
     401: Error401;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
     /**
      * Internal Server Error
      */
     500: Error500;
 };
-export type UserQuotaShowError = UserQuotaShowErrors[keyof UserQuotaShowErrors];
-export type UserQuotaShowResponses = {
+export type GetQuotaError = GetQuotaErrors[keyof GetQuotaErrors];
+export type GetQuotaResponses = {
     /**
      * OK
      */
     200: UserQuotaResponse;
 };
-export type UserQuotaShowResponse = UserQuotaShowResponses[keyof UserQuotaShowResponses];
-export type UserReportIndexData = {
+export type GetQuotaResponse = GetQuotaResponses[keyof GetQuotaResponses];
+export type ListReportsData = {
     body?: never;
     path?: never;
     query?: {
@@ -3121,7 +3460,7 @@ export type UserReportIndexData = {
         /**
          * Number of results per page
          */
-        size?: number;
+        limit?: number;
         /**
          * Filter by report status
          */
@@ -3129,7 +3468,7 @@ export type UserReportIndexData = {
     };
     url: '/v1/user/reports';
 };
-export type UserReportIndexErrors = {
+export type ListReportsErrors = {
     /**
      * Unauthorized
      */
@@ -3139,21 +3478,21 @@ export type UserReportIndexErrors = {
      */
     500: Error500;
 };
-export type UserReportIndexError = UserReportIndexErrors[keyof UserReportIndexErrors];
-export type UserReportIndexResponses = {
+export type ListReportsError = ListReportsErrors[keyof ListReportsErrors];
+export type ListReportsResponses = {
     /**
      * OK
      */
     200: ReportListResponse;
 };
-export type UserReportIndexResponse = UserReportIndexResponses[keyof UserReportIndexResponses];
-export type UserReportCreateData = {
+export type ListReportsResponse = ListReportsResponses[keyof ListReportsResponses];
+export type CreateReportData = {
     body: CreateReportRequest;
     path?: never;
     query?: never;
     url: '/v1/user/reports';
 };
-export type UserReportCreateErrors = {
+export type CreateReportErrors = {
     /**
      * Bad Request
      */
@@ -3171,21 +3510,21 @@ export type UserReportCreateErrors = {
      */
     500: Error500;
 };
-export type UserReportCreateError = UserReportCreateErrors[keyof UserReportCreateErrors];
-export type UserReportCreateResponses = {
+export type CreateReportError = CreateReportErrors[keyof CreateReportErrors];
+export type CreateReportResponses = {
     /**
      * Report created successfully
      */
     201: Report;
 };
-export type UserReportCreateResponse = UserReportCreateResponses[keyof UserReportCreateResponses];
-export type UserPreferencesShowData = {
+export type CreateReportResponse = CreateReportResponses[keyof CreateReportResponses];
+export type GetPreferencesData = {
     body?: never;
     path?: never;
     query?: never;
     url: '/v1/user/preferences';
 };
-export type UserPreferencesShowErrors = {
+export type GetPreferencesErrors = {
     /**
      * Unauthorized
      */
@@ -3195,21 +3534,21 @@ export type UserPreferencesShowErrors = {
      */
     500: Error500;
 };
-export type UserPreferencesShowError = UserPreferencesShowErrors[keyof UserPreferencesShowErrors];
-export type UserPreferencesShowResponses = {
+export type GetPreferencesError = GetPreferencesErrors[keyof GetPreferencesErrors];
+export type GetPreferencesResponses = {
     /**
      * OK
      */
     200: UserPreferences;
 };
-export type UserPreferencesShowResponse = UserPreferencesShowResponses[keyof UserPreferencesShowResponses];
-export type UserPreferencesUpdateData = {
+export type GetPreferencesResponse = GetPreferencesResponses[keyof GetPreferencesResponses];
+export type UpdatePreferencesData = {
     body: UserPreferences;
     path?: never;
     query?: never;
     url: '/v1/user/preferences';
 };
-export type UserPreferencesUpdateErrors = {
+export type UpdatePreferencesErrors = {
     /**
      * Unauthorized
      */
@@ -3219,15 +3558,15 @@ export type UserPreferencesUpdateErrors = {
      */
     500: Error500;
 };
-export type UserPreferencesUpdateError = UserPreferencesUpdateErrors[keyof UserPreferencesUpdateErrors];
-export type UserPreferencesUpdateResponses = {
+export type UpdatePreferencesError = UpdatePreferencesErrors[keyof UpdatePreferencesErrors];
+export type UpdatePreferencesResponses = {
     /**
      * OK
      */
     200: UserPreferences;
 };
-export type UserPreferencesUpdateResponse = UserPreferencesUpdateResponses[keyof UserPreferencesUpdateResponses];
-export type UserActivityDestroyData = {
+export type UpdatePreferencesResponse = UpdatePreferencesResponses[keyof UpdatePreferencesResponses];
+export type DeleteActivityData = {
     body?: never;
     path?: never;
     query?: {
@@ -3238,7 +3577,7 @@ export type UserActivityDestroyData = {
     };
     url: '/v1/user/activity';
 };
-export type UserActivityDestroyErrors = {
+export type DeleteActivityErrors = {
     /**
      * Unauthorized
      */
@@ -3248,8 +3587,8 @@ export type UserActivityDestroyErrors = {
      */
     500: Error500;
 };
-export type UserActivityDestroyError = UserActivityDestroyErrors[keyof UserActivityDestroyErrors];
-export type UserActivityDestroyResponses = {
+export type DeleteActivityError = DeleteActivityErrors[keyof DeleteActivityErrors];
+export type DeleteActivityResponses = {
     /**
      * OK
      */
@@ -3258,8 +3597,8 @@ export type UserActivityDestroyResponses = {
         deletedCount: number;
     };
 };
-export type UserActivityDestroyResponse = UserActivityDestroyResponses[keyof UserActivityDestroyResponses];
-export type UserActivityIndexData = {
+export type DeleteActivityResponse = DeleteActivityResponses[keyof DeleteActivityResponses];
+export type ListActivityData = {
     body?: never;
     path?: never;
     query?: {
@@ -3270,15 +3609,19 @@ export type UserActivityIndexData = {
         /**
          * Number of results per page
          */
-        size?: number;
+        limit?: number;
         /**
          * Filter by activity type
          */
         activityType?: ActivityType;
+        /**
+         * Filter activities to a specific date (YYYY-MM-DD)
+         */
+        date?: string;
     };
     url: '/v1/user/activity';
 };
-export type UserActivityIndexErrors = {
+export type ListActivityErrors = {
     /**
      * Unauthorized
      */
@@ -3288,25 +3631,33 @@ export type UserActivityIndexErrors = {
      */
     500: Error500;
 };
-export type UserActivityIndexError = UserActivityIndexErrors[keyof UserActivityIndexErrors];
-export type UserActivityIndexResponses = {
+export type ListActivityError = ListActivityErrors[keyof ListActivityErrors];
+export type ListActivityResponses = {
     /**
      * OK
      */
     200: {
-        data: Array<UserActivity>;
-        hasMore: boolean;
-        cursor?: number;
+        activities: Array<UserActivity>;
+        pagination: CursorPagination;
     };
 };
-export type UserActivityIndexResponse = UserActivityIndexResponses[keyof UserActivityIndexResponses];
-export type UserActivityStatsShowData = {
+export type ListActivityResponse = ListActivityResponses[keyof ListActivityResponses];
+export type GetActivityHeatmapData = {
     body?: never;
     path?: never;
-    query?: never;
-    url: '/v1/user/activity/stats';
+    query?: {
+        /**
+         * Number of days to include in the heatmap
+         */
+        days?: number;
+        /**
+         * Filter by activity type
+         */
+        activityType?: ActivityType;
+    };
+    url: '/v1/user/activity/heatmap';
 };
-export type UserActivityStatsShowErrors = {
+export type GetActivityHeatmapErrors = {
     /**
      * Unauthorized
      */
@@ -3316,34 +3667,33 @@ export type UserActivityStatsShowErrors = {
      */
     500: Error500;
 };
-export type UserActivityStatsShowError = UserActivityStatsShowErrors[keyof UserActivityStatsShowErrors];
-export type UserActivityStatsShowResponses = {
+export type GetActivityHeatmapError = GetActivityHeatmapErrors[keyof GetActivityHeatmapErrors];
+export type GetActivityHeatmapResponses = {
     /**
      * OK
      */
     200: {
-        totalSearches: number;
-        totalExports: number;
-        totalPlays: number;
-        totalListAdds: number;
         /**
-         * Consecutive days with at least one activity
+         * Map of YYYY-MM-DD date strings to activity counts
          */
-        streakDays: number;
-        topMedia: Array<{
-            mediaId: number;
-            count: number;
-        }>;
+        counts: {
+            [key: string]: number;
+        };
     };
 };
-export type UserActivityStatsShowResponse = UserActivityStatsShowResponses[keyof UserActivityStatsShowResponses];
-export type UserExportShowData = {
+export type GetActivityHeatmapResponse = GetActivityHeatmapResponses[keyof GetActivityHeatmapResponses];
+export type GetActivityStatsData = {
     body?: never;
     path?: never;
-    query?: never;
-    url: '/v1/user/export';
+    query?: {
+        /**
+         * Only count activities from this date onward (YYYY-MM-DD)
+         */
+        since?: string;
+    };
+    url: '/v1/user/activity/stats';
 };
-export type UserExportShowErrors = {
+export type GetActivityStatsErrors = {
     /**
      * Unauthorized
      */
@@ -3353,150 +3703,101 @@ export type UserExportShowErrors = {
      */
     500: Error500;
 };
-export type UserExportShowError = UserExportShowErrors[keyof UserExportShowErrors];
-export type UserExportShowResponses = {
+export type GetActivityStatsError = GetActivityStatsErrors[keyof GetActivityStatsErrors];
+export type GetActivityStatsResponses = {
     /**
      * OK
      */
     200: {
-        profile: {
-            id?: number;
-            username?: string;
-            email?: string;
-            createdAt?: string;
-        };
-        preferences: UserPreferences;
-        activity: Array<UserActivity>;
-        lists: Array<{
-            [key: string]: unknown;
-        }>;
-        reports: Array<{
-            [key: string]: unknown;
+        totalSearches: number;
+        totalExports: number;
+        totalPlays: number;
+        totalListAdds: number;
+        /**
+         * Consecutive days with at least one activity
+         */
+        streakDays: number;
+        topMedia: Array<{
+            mediaId: number;
+            count: number;
         }>;
     };
 };
-export type UserExportShowResponse = UserExportShowResponses[keyof UserExportShowResponses];
-export type LabIndexData = {
+export type GetActivityStatsResponse = GetActivityStatsResponses[keyof GetActivityStatsResponses];
+export type ExportDataData = {
     body?: never;
     path?: never;
     query?: never;
-    url: '/v1/labs';
-};
-export type LabIndexErrors = {
-    /**
-     * Internal Server Error
-     */
-    500: Error500;
-};
-export type LabIndexError = LabIndexErrors[keyof LabIndexErrors];
-export type LabIndexResponses = {
-    /**
-     * OK
-     */
-    200: Array<LabFeature>;
-};
-export type LabIndexResponse = LabIndexResponses[keyof LabIndexResponses];
-export type ListIndexData = {
-    body?: never;
-    path?: never;
-    query?: {
-        /**
-         * Filter by visibility
-         */
-        visibility?: 'public' | 'private';
-        /**
-         * Filter by list type
-         */
-        type?: 'SERIES' | 'CUSTOM' | 'SEGMENT';
-        /**
-         * Filter by list owner user ID
-         */
-        userId?: number;
-        /**
-         * Filter lists containing this media ID
-         */
-        mediaId?: number;
-    };
-    url: '/v1/lists';
+    url: '/v1/user/export';
 };
-export type ListIndexErrors = {
-    /**
-     * Bad Request
-     */
-    400: Error400;
+export type ExportDataErrors = {
     /**
      * Unauthorized
      */
     401: Error401;
-    /**
-     * Forbidden
-     */
-    403: Error403;
-    /**
-     * Too Many Requests
-     */
-    429: Error429;
     /**
      * Internal Server Error
      */
     500: Error500;
 };
-export type ListIndexError = ListIndexErrors[keyof ListIndexErrors];
-export type ListIndexResponses = {
+export type ExportDataError = ExportDataErrors[keyof ExportDataErrors];
+export type ExportDataResponses = {
     /**
      * OK
      */
-    200: Array<List>;
+    200: UserExportResponse;
 };
-export type ListIndexResponse = ListIndexResponses[keyof ListIndexResponses];
-export type ListCreateData = {
-    body: ListCreateRequest;
+export type ExportDataResponse = ExportDataResponses[keyof ExportDataResponses];
+export type ListLabsData = {
+    body?: never;
     path?: never;
     query?: never;
-    url: '/v1/lists';
+    url: '/v1/user/labs';
 };
-export type ListCreateErrors = {
-    /**
-     * Bad Request
-     */
-    400: Error400;
+export type ListLabsErrors = {
     /**
      * Unauthorized
      */
     401: Error401;
-    /**
-     * Forbidden
-     */
-    403: Error403;
-    /**
-     * Too Many Requests
-     */
-    429: Error429;
     /**
      * Internal Server Error
      */
     500: Error500;
 };
-export type ListCreateError = ListCreateErrors[keyof ListCreateErrors];
-export type ListCreateResponses = {
+export type ListLabsError = ListLabsErrors[keyof ListLabsErrors];
+export type ListLabsResponses = {
     /**
-     * Created
+     * OK
      */
-    201: List;
+    200: Array<UserLabFeature>;
 };
-export type ListCreateResponse = ListCreateResponses[keyof ListCreateResponses];
-export type ListDestroyData = {
+export type ListLabsResponse = ListLabsResponses[keyof ListLabsResponses];
+export type ListCollectionsData = {
     body?: never;
-    path: {
+    path?: never;
+    query?: {
+        /**
+         * Filter by visibility
+         */
+        visibility?: 'public' | 'private';
         /**
-         * List ID
+         * Cursor offset for pagination
          */
-        id: number;
+        cursor?: number;
+        /**
+         * Page number (1-indexed)
+         *
+         * @deprecated
+         */
+        page?: number;
+        /**
+         * Items per page
+         */
+        limit?: number;
     };
-    query?: never;
-    url: '/v1/lists/{id}';
+    url: '/v1/collections';
 };
-export type ListDestroyErrors = {
+export type ListCollectionsErrors = {
     /**
      * Bad Request
      */
@@ -3509,10 +3810,6 @@ export type ListDestroyErrors = {
      * Forbidden
      */
     403: Error403;
-    /**
-     * Not Found
-     */
-    404: Error404;
     /**
      * Too Many Requests
      */
@@ -3522,29 +3819,21 @@ export type ListDestroyErrors = {
      */
     500: Error500;
 };
-export type ListDestroyError = ListDestroyErrors[keyof ListDestroyErrors];
-export type ListDestroyResponses = {
+export type ListCollectionsError = ListCollectionsErrors[keyof ListCollectionsErrors];
+export type ListCollectionsResponses = {
     /**
      * OK
      */
-    200: {
-        message?: string;
-        id?: number;
-    };
+    200: CollectionListResponse;
 };
-export type ListDestroyResponse = ListDestroyResponses[keyof ListDestroyResponses];
-export type ListShowData = {
-    body?: never;
-    path: {
-        /**
-         * List ID
-         */
-        id: number;
-    };
+export type ListCollectionsResponse = ListCollectionsResponses[keyof ListCollectionsResponses];
+export type CreateCollectionData = {
+    body: CollectionRequests;
+    path?: never;
     query?: never;
-    url: '/v1/lists/{id}';
+    url: '/v1/collections';
 };
-export type ListShowErrors = {
+export type CreateCollectionErrors = {
     /**
      * Bad Request
      */
@@ -3557,10 +3846,6 @@ export type ListShowErrors = {
      * Forbidden
      */
     403: Error403;
-    /**
-     * Not Found
-     */
-    404: Error404;
     /**
      * Too Many Requests
      */
@@ -3570,29 +3855,26 @@ export type ListShowErrors = {
      */
     500: Error500;
 };
-export type ListShowError = ListShowErrors[keyof ListShowErrors];
-export type ListShowResponses = {
+export type CreateCollectionError = CreateCollectionErrors[keyof CreateCollectionErrors];
+export type CreateCollectionResponses = {
     /**
-     * OK
+     * Created
      */
-    200: ListWithMedia;
+    201: Collection;
 };
-export type ListShowResponse = ListShowResponses[keyof ListShowResponses];
-export type ListUpdateData = {
-    body: {
-        name?: string;
-        visibility?: 'PUBLIC' | 'PRIVATE';
-    };
+export type CreateCollectionResponse = CreateCollectionResponses[keyof CreateCollectionResponses];
+export type DeleteCollectionData = {
+    body?: never;
     path: {
         /**
-         * List ID
+         * Collection ID
          */
         id: number;
     };
     query?: never;
-    url: '/v1/lists/{id}';
+    url: '/v1/collections/{id}';
 };
-export type ListUpdateErrors = {
+export type DeleteCollectionErrors = {
     /**
      * Bad Request
      */
@@ -3618,32 +3900,41 @@ export type ListUpdateErrors = {
      */
     500: Error500;
 };
-export type ListUpdateError = ListUpdateErrors[keyof ListUpdateErrors];
-export type ListUpdateResponses = {
+export type DeleteCollectionError = DeleteCollectionErrors[keyof DeleteCollectionErrors];
+export type DeleteCollectionResponses = {
     /**
-     * OK
+     * No Content
      */
-    200: List;
+    204: void;
 };
-export type ListUpdateResponse = ListUpdateResponses[keyof ListUpdateResponses];
-export type ListAddItemData = {
-    body: {
-        mediaId: number;
+export type DeleteCollectionResponse = DeleteCollectionResponses[keyof DeleteCollectionResponses];
+export type GetCollectionData = {
+    body?: never;
+    path: {
         /**
-         * Position in the list (1-indexed)
+         * Collection ID
          */
-        position: number;
+        id: number;
     };
-    path: {
+    query?: {
         /**
-         * List ID
+         * Cursor offset for paginated segments
          */
-        id: number;
+        cursor?: number;
+        /**
+         * Page number (1-indexed)
+         *
+         * @deprecated
+         */
+        page?: number;
+        /**
+         * Items per page
+         */
+        limit?: number;
     };
-    query?: never;
-    url: '/v1/lists/{id}/items';
+    url: '/v1/collections/{id}';
 };
-export type ListAddItemErrors = {
+export type GetCollectionErrors = {
     /**
      * Bad Request
      */
@@ -3660,10 +3951,6 @@ export type ListAddItemErrors = {
      * Not Found
      */
     404: Error404;
-    /**
-     * Conflict
-     */
-    409: Error409;
     /**
      * Too Many Requests
      */
@@ -3673,32 +3960,29 @@ export type ListAddItemErrors = {
      */
     500: Error500;
 };
-export type ListAddItemError = ListAddItemErrors[keyof ListAddItemErrors];
-export type ListAddItemResponses = {
+export type GetCollectionError = GetCollectionErrors[keyof GetCollectionErrors];
+export type GetCollectionResponses = {
     /**
-     * Created
+     * OK
      */
-    201: {
-        message?: string;
-    };
+    200: CollectionWithSegments;
 };
-export type ListAddItemResponse = ListAddItemResponses[keyof ListAddItemResponses];
-export type ListRemoveItemData = {
-    body?: never;
+export type GetCollectionResponse = GetCollectionResponses[keyof GetCollectionResponses];
+export type UpdateCollectionData = {
+    body: {
+        name?: string;
+        visibility?: 'PUBLIC' | 'PRIVATE';
+    };
     path: {
         /**
-         * List ID
+         * Collection ID
          */
         id: number;
-        /**
-         * Media ID
-         */
-        mediaId: number;
     };
     query?: never;
-    url: '/v1/lists/{id}/items/{mediaId}';
+    url: '/v1/collections/{id}';
 };
-export type ListRemoveItemErrors = {
+export type UpdateCollectionErrors = {
     /**
      * Bad Request
      */
@@ -3724,37 +4008,35 @@ export type ListRemoveItemErrors = {
      */
     500: Error500;
 };
-export type ListRemoveItemError = ListRemoveItemErrors[keyof ListRemoveItemErrors];
-export type ListRemoveItemResponses = {
+export type UpdateCollectionError = UpdateCollectionErrors[keyof UpdateCollectionErrors];
+export type UpdateCollectionResponses = {
     /**
      * OK
      */
-    200: {
-        message?: string;
-    };
+    200: Collection;
 };
-export type ListRemoveItemResponse = ListRemoveItemResponses[keyof ListRemoveItemResponses];
-export type ListUpdateItemData = {
+export type UpdateCollectionResponse = UpdateCollectionResponses[keyof UpdateCollectionResponses];
+export type AddSegmentToCollectionData = {
     body: {
         /**
-         * New position in the list (1-indexed)
+         * UUID of the segment to add
          */
-        position: number;
+        segmentUuid: string;
+        /**
+         * Optional annotation
+         */
+        note?: string;
     };
     path: {
         /**
-         * List ID
+         * Collection ID
          */
         id: number;
-        /**
-         * Media ID
-         */
-        mediaId: number;
     };
     query?: never;
-    url: '/v1/lists/{id}/items/{mediaId}';
+    url: '/v1/collections/{id}/segments';
 };
-export type ListUpdateItemErrors = {
+export type AddSegmentToCollectionErrors = {
     /**
      * Bad Request
      */
@@ -3780,37 +4062,30 @@ export type ListUpdateItemErrors = {
      */
     500: Error500;
 };
-export type ListUpdateItemError = ListUpdateItemErrors[keyof ListUpdateItemErrors];
-export type ListUpdateItemResponses = {
+export type AddSegmentToCollectionError = AddSegmentToCollectionErrors[keyof AddSegmentToCollectionErrors];
+export type AddSegmentToCollectionResponses = {
     /**
-     * OK
+     * No Content
      */
-    200: {
-        message?: string;
-    };
+    204: void;
 };
-export type ListUpdateItemResponse = ListUpdateItemResponses[keyof ListUpdateItemResponses];
-export type ListGetSegmentsData = {
+export type AddSegmentToCollectionResponse = AddSegmentToCollectionResponses[keyof AddSegmentToCollectionResponses];
+export type RemoveSegmentFromCollectionData = {
     body?: never;
     path: {
         /**
-         * List ID
+         * Collection ID
          */
         id: number;
-    };
-    query?: {
-        /**
-         * Page number (1-indexed)
-         */
-        page?: number;
         /**
-         * Items per page
+         * Segment UUID
          */
-        limit?: number;
+        uuid: string;
     };
-    url: '/v1/lists/{id}/segments';
+    query?: never;
+    url: '/v1/collections/{id}/segments/{uuid}';
 };
-export type ListGetSegmentsErrors = {
+export type RemoveSegmentFromCollectionErrors = {
     /**
      * Bad Request
      */
@@ -3836,35 +4111,39 @@ export type ListGetSegmentsErrors = {
      */
     500: Error500;
 };
-export type ListGetSegmentsError = ListGetSegmentsErrors[keyof ListGetSegmentsErrors];
-export type ListGetSegmentsResponses = {
+export type RemoveSegmentFromCollectionError = RemoveSegmentFromCollectionErrors[keyof RemoveSegmentFromCollectionErrors];
+export type RemoveSegmentFromCollectionResponses = {
     /**
-     * OK
+     * No Content
      */
-    200: ListWithSegments;
+    204: void;
 };
-export type ListGetSegmentsResponse = ListGetSegmentsResponses[keyof ListGetSegmentsResponses];
-export type ListAddSegmentData = {
+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: {
         /**
-         * List ID
+         * Collection ID
          */
         id: number;
+        /**
+         * Segment UUID
+         */
+        uuid: string;
     };
     query?: never;
-    url: '/v1/lists/{id}/segments';
+    url: '/v1/collections/{id}/segments/{uuid}';
 };
-export type ListAddSegmentErrors = {
+export type UpdateCollectionSegmentErrors = {
     /**
      * Bad Request
      */
@@ -3881,10 +4160,6 @@ export type ListAddSegmentErrors = {
      * Not Found
      */
     404: Error404;
-    /**
-     * Conflict
-     */
-    409: Error409;
     /**
      * Too Many Requests
      */
@@ -3894,36 +4169,21 @@ export type ListAddSegmentErrors = {
      */
     500: Error500;
 };
-export type ListAddSegmentError = ListAddSegmentErrors[keyof ListAddSegmentErrors];
-export type ListAddSegmentResponses = {
+export type UpdateCollectionSegmentError = UpdateCollectionSegmentErrors[keyof UpdateCollectionSegmentErrors];
+export type UpdateCollectionSegmentResponses = {
     /**
-     * Created
+     * No Content
      */
-    201: {
-        message?: string;
-    };
+    204: void;
 };
-export type ListAddSegmentResponse = ListAddSegmentResponses[keyof ListAddSegmentResponses];
-export type ListRemoveSegmentData = {
+export type UpdateCollectionSegmentResponse = UpdateCollectionSegmentResponses[keyof UpdateCollectionSegmentResponses];
+export type GetAdminDashboardData = {
     body?: never;
-    path: {
-        /**
-         * List ID
-         */
-        id: number;
-        /**
-         * Segment UUID
-         */
-        uuid: string;
-    };
+    path?: never;
     query?: never;
-    url: '/v1/lists/{id}/segments/{uuid}';
+    url: '/v1/admin/dashboard';
 };
-export type ListRemoveSegmentErrors = {
-    /**
-     * Bad Request
-     */
-    400: Error400;
+export type GetAdminDashboardErrors = {
     /**
      * Unauthorized
      */
@@ -3932,10 +4192,6 @@ export type ListRemoveSegmentErrors = {
      * Forbidden
      */
     403: Error403;
-    /**
-     * Not Found
-     */
-    404: Error404;
     /**
      * Too Many Requests
      */
@@ -3945,45 +4201,81 @@ export type ListRemoveSegmentErrors = {
      */
     500: Error500;
 };
-export type ListRemoveSegmentError = ListRemoveSegmentErrors[keyof ListRemoveSegmentErrors];
-export type ListRemoveSegmentResponses = {
+export type GetAdminDashboardError = GetAdminDashboardErrors[keyof GetAdminDashboardErrors];
+export type GetAdminDashboardResponses = {
     /**
      * OK
      */
     200: {
-        message?: string;
+        media: {
+            totalMedia: number;
+            totalEpisodes: number;
+            totalSegments: number;
+            totalCharacters: number;
+            totalSeiyuu: number;
+        };
+        users: {
+            totalUsers: number;
+            /**
+             * Users registered in the last 30 days
+             */
+            recentlyRegisteredCount: number;
+            /**
+             * Users active in the last 30 days
+             */
+            recentlyActiveCount: number;
+        };
+        activity: {
+            totalSearches: number;
+            totalExports: number;
+            totalPlays: number;
+            totalCollectionAdds: number;
+            /**
+             * Unique users who searched in the last 7 days
+             */
+            activeSearchers7d: number;
+            topQueries7d: Array<{
+                query: string;
+                count: number;
+            }>;
+            dailyActivity30d: Array<{
+                date: string;
+                count: number;
+            }>;
+        };
+        system: {
+            status: 'healthy' | 'degraded';
+            app: {
+                version: string;
+            };
+            elasticsearch: {
+                status: 'connected' | 'disconnected';
+                version?: string;
+                clusterName?: string;
+                clusterStatus?: string;
+                indexName?: string;
+                documentCount?: number;
+            };
+            database: {
+                status: 'connected' | 'disconnected';
+                version?: string;
+            };
+            queues: Array<{
+                queue: string;
+                stuckCount: number;
+                failedCount: number;
+            }>;
+        };
     };
 };
-export type ListRemoveSegmentResponse = ListRemoveSegmentResponses[keyof ListRemoveSegmentResponses];
-export type ListUpdateSegmentData = {
-    body: {
-        /**
-         * New position in the list
-         */
-        position?: number;
-        /**
-         * Updated annotation
-         */
-        note?: string;
-    };
-    path: {
-        /**
-         * List ID
-         */
-        id: number;
-        /**
-         * Segment UUID
-         */
-        uuid: string;
-    };
+export type GetAdminDashboardResponse = GetAdminDashboardResponses[keyof GetAdminDashboardResponses];
+export type GetAdminHealthData = {
+    body?: never;
+    path?: never;
     query?: never;
-    url: '/v1/lists/{id}/segments/{uuid}';
+    url: '/v1/admin/health';
 };
-export type ListUpdateSegmentErrors = {
-    /**
-     * Bad Request
-     */
-    400: Error400;
+export type GetAdminHealthErrors = {
     /**
      * Unauthorized
      */
@@ -3992,10 +4284,6 @@ export type ListUpdateSegmentErrors = {
      * Forbidden
      */
     403: Error403;
-    /**
-     * Not Found
-     */
-    404: Error404;
     /**
      * Too Many Requests
      */
@@ -4005,23 +4293,47 @@ export type ListUpdateSegmentErrors = {
      */
     500: Error500;
 };
-export type ListUpdateSegmentError = ListUpdateSegmentErrors[keyof ListUpdateSegmentErrors];
-export type ListUpdateSegmentResponses = {
+export type GetAdminHealthError = GetAdminHealthErrors[keyof GetAdminHealthErrors];
+export type GetAdminHealthResponses = {
     /**
      * OK
      */
     200: {
-        message?: string;
+        /**
+         * Overall system status
+         */
+        status: 'healthy' | 'degraded';
+        app: {
+            /**
+             * API version from OpenAPI spec
+             */
+            version: string;
+        };
+        elasticsearch: {
+            status: 'connected' | 'disconnected';
+            version?: string;
+            clusterName?: string;
+            /**
+             * ES cluster health (green, yellow, red)
+             */
+            clusterStatus?: string;
+            indexName?: string;
+            documentCount?: number;
+        };
+        database: {
+            status: 'connected' | 'disconnected';
+            version?: string;
+        };
     };
 };
-export type ListUpdateSegmentResponse = ListUpdateSegmentResponses[keyof ListUpdateSegmentResponses];
-export type AdminReindexCreateData = {
+export type GetAdminHealthResponse = GetAdminHealthResponses[keyof GetAdminHealthResponses];
+export type TriggerReindexData = {
     body?: ReindexRequest;
     path?: never;
     query?: never;
     url: '/v1/admin/reindex';
 };
-export type AdminReindexCreateErrors = {
+export type TriggerReindexErrors = {
     /**
      * Bad Request
      */
@@ -4043,21 +4355,21 @@ export type AdminReindexCreateErrors = {
      */
     500: Error500;
 };
-export type AdminReindexCreateError = AdminReindexCreateErrors[keyof AdminReindexCreateErrors];
-export type AdminReindexCreateResponses = {
+export type TriggerReindexError = TriggerReindexErrors[keyof TriggerReindexErrors];
+export type TriggerReindexResponses = {
     /**
      * Reindex operation completed
      */
     200: ReindexResponse;
 };
-export type AdminReindexCreateResponse = AdminReindexCreateResponses[keyof AdminReindexCreateResponses];
-export type AdminQueueStatsIndexData = {
+export type TriggerReindexResponse = TriggerReindexResponses[keyof TriggerReindexResponses];
+export type ListAdminQueueStatsData = {
     body?: never;
     path?: never;
     query?: never;
     url: '/v1/admin/queues/stats';
 };
-export type AdminQueueStatsIndexErrors = {
+export type ListAdminQueueStatsErrors = {
     /**
      * Bad Request
      */
@@ -4079,8 +4391,8 @@ export type AdminQueueStatsIndexErrors = {
      */
     500: Error500;
 };
-export type AdminQueueStatsIndexError = AdminQueueStatsIndexErrors[keyof AdminQueueStatsIndexErrors];
-export type AdminQueueStatsIndexResponses = {
+export type ListAdminQueueStatsError = ListAdminQueueStatsErrors[keyof ListAdminQueueStatsErrors];
+export type ListAdminQueueStatsResponses = {
     /**
      * Queue statistics retrieved successfully
      */
@@ -4096,8 +4408,8 @@ export type AdminQueueStatsIndexResponses = {
         failedCount?: number;
     }>;
 };
-export type AdminQueueStatsIndexResponse = AdminQueueStatsIndexResponses[keyof AdminQueueStatsIndexResponses];
-export type AdminQueueShowData = {
+export type ListAdminQueueStatsResponse = ListAdminQueueStatsResponses[keyof ListAdminQueueStatsResponses];
+export type GetAdminQueueData = {
     body?: never;
     path: {
         /**
@@ -4108,7 +4420,7 @@ export type AdminQueueShowData = {
     query?: never;
     url: '/v1/admin/queues/{queueName}';
 };
-export type AdminQueueShowErrors = {
+export type GetAdminQueueErrors = {
     /**
      * Bad Request
      */
@@ -4134,41 +4446,55 @@ export type AdminQueueShowErrors = {
      */
     500: Error500;
 };
-export type AdminQueueShowError = AdminQueueShowErrors[keyof AdminQueueShowErrors];
-export type AdminQueueShowResponses = {
+export type GetAdminQueueError = GetAdminQueueErrors[keyof GetAdminQueueErrors];
+export type GetAdminQueueResponses = {
     /**
      * Queue details retrieved successfully
      */
     200: {
-        queue?: string;
-        /**
-         * Current queue size (pending jobs)
-         */
-        size?: number;
-        /**
-         * Total jobs created
-         */
-        created?: number;
-        /**
-         * Total failed jobs
-         */
-        failed?: number;
-        /**
-         * Total completed jobs
-         */
-        complete?: number;
-        /**
-         * Total expired jobs
-         */
-        expired?: number;
-        /**
-         * Total cancelled jobs
-         */
-        cancelled?: number;
+        queue: string;
+        stats: {
+            /**
+             * Jobs scheduled for future execution (`start_after > now()`)
+             */
+            deferred: number;
+            /**
+             * Jobs currently queued and waiting to be processed
+             */
+            queued: number;
+            /**
+             * Jobs currently being processed
+             */
+            active: number;
+            /**
+             * Total jobs currently stored in the queue table
+             */
+            total: number;
+        };
+        metadata: {
+            policy: string;
+            partition: boolean;
+            deadLetter?: string;
+            warningQueueSize?: number;
+            retryLimit?: number;
+            /**
+             * Initial retry delay in seconds
+             */
+            retryDelay?: number;
+            retryBackoff?: boolean;
+            retryDelayMax?: number;
+            expireInSeconds?: number;
+            retentionSeconds?: number;
+            deleteAfterSeconds?: number;
+            createdOn: string;
+            updatedOn: string;
+            singletonsActive: Array<string>;
+            table: string;
+        };
     };
 };
-export type AdminQueueShowResponse = AdminQueueShowResponses[keyof AdminQueueShowResponses];
-export type AdminQueueFailedIndexData = {
+export type GetAdminQueueResponse = GetAdminQueueResponses[keyof GetAdminQueueResponses];
+export type ListAdminQueueFailedData = {
     body?: never;
     path: {
         /**
@@ -4179,7 +4505,7 @@ export type AdminQueueFailedIndexData = {
     query?: never;
     url: '/v1/admin/queues/{queueName}/failed';
 };
-export type AdminQueueFailedIndexErrors = {
+export type ListAdminQueueFailedErrors = {
     /**
      * Bad Request
      */
@@ -4201,8 +4527,8 @@ export type AdminQueueFailedIndexErrors = {
      */
     500: Error500;
 };
-export type AdminQueueFailedIndexError = AdminQueueFailedIndexErrors[keyof AdminQueueFailedIndexErrors];
-export type AdminQueueFailedIndexResponses = {
+export type ListAdminQueueFailedError = ListAdminQueueFailedErrors[keyof ListAdminQueueFailedErrors];
+export type ListAdminQueueFailedResponses = {
     /**
      * Failed jobs retrieved successfully
      */
@@ -4225,8 +4551,8 @@ export type AdminQueueFailedIndexResponses = {
         createdOn?: string;
     }>;
 };
-export type AdminQueueFailedIndexResponse = AdminQueueFailedIndexResponses[keyof AdminQueueFailedIndexResponses];
-export type AdminQueueRetryCreateData = {
+export type ListAdminQueueFailedResponse = ListAdminQueueFailedResponses[keyof ListAdminQueueFailedResponses];
+export type RetryAdminQueueFailedData = {
     body?: never;
     path: {
         /**
@@ -4237,7 +4563,7 @@ export type AdminQueueRetryCreateData = {
     query?: never;
     url: '/v1/admin/queues/{queueName}/retry';
 };
-export type AdminQueueRetryCreateErrors = {
+export type RetryAdminQueueFailedErrors = {
     /**
      * Bad Request
      */
@@ -4259,8 +4585,8 @@ export type AdminQueueRetryCreateErrors = {
      */
     500: Error500;
 };
-export type AdminQueueRetryCreateError = AdminQueueRetryCreateErrors[keyof AdminQueueRetryCreateErrors];
-export type AdminQueueRetryCreateResponses = {
+export type RetryAdminQueueFailedError = RetryAdminQueueFailedErrors[keyof RetryAdminQueueFailedErrors];
+export type RetryAdminQueueFailedResponses = {
     /**
      * Jobs queued for retry
      */
@@ -4273,8 +4599,8 @@ export type AdminQueueRetryCreateResponses = {
         message?: string;
     };
 };
-export type AdminQueueRetryCreateResponse = AdminQueueRetryCreateResponses[keyof AdminQueueRetryCreateResponses];
-export type AdminQueueFailedDestroyData = {
+export type RetryAdminQueueFailedResponse = RetryAdminQueueFailedResponses[keyof RetryAdminQueueFailedResponses];
+export type PurgeAdminQueueFailedData = {
     body?: never;
     path: {
         /**
@@ -4285,7 +4611,7 @@ export type AdminQueueFailedDestroyData = {
     query?: never;
     url: '/v1/admin/queues/{queueName}/purge';
 };
-export type AdminQueueFailedDestroyErrors = {
+export type PurgeAdminQueueFailedErrors = {
     /**
      * Bad Request
      */
@@ -4307,8 +4633,8 @@ export type AdminQueueFailedDestroyErrors = {
      */
     500: Error500;
 };
-export type AdminQueueFailedDestroyError = AdminQueueFailedDestroyErrors[keyof AdminQueueFailedDestroyErrors];
-export type AdminQueueFailedDestroyResponses = {
+export type PurgeAdminQueueFailedError = PurgeAdminQueueFailedErrors[keyof PurgeAdminQueueFailedErrors];
+export type PurgeAdminQueueFailedResponses = {
     /**
      * Failed jobs purged successfully
      */
@@ -4321,29 +4647,8 @@ export type AdminQueueFailedDestroyResponses = {
         message?: string;
     };
 };
-export type AdminQueueFailedDestroyResponse = AdminQueueFailedDestroyResponses[keyof AdminQueueFailedDestroyResponses];
-export type AdminMorphemeBackfillCreateData = {
-    body?: never;
-    path?: never;
-    query?: never;
-    url: '/v1/admin/morpheme-backfill';
-};
-export type AdminMorphemeBackfillCreateResponses = {
-    /**
-     * Backfill completed
-     */
-    200: {
-        success: boolean;
-        message: string;
-        stats: {
-            totalSegments: number;
-            successfulAnalyses: number;
-            failedAnalyses: number;
-        };
-    };
-};
-export type AdminMorphemeBackfillCreateResponse = AdminMorphemeBackfillCreateResponses[keyof AdminMorphemeBackfillCreateResponses];
-export type AdminReportIndexData = {
+export type PurgeAdminQueueFailedResponse = PurgeAdminQueueFailedResponses[keyof PurgeAdminQueueFailedResponses];
+export type ListAdminReportsData = {
     body?: never;
     path?: never;
     query?: {
@@ -4354,7 +4659,7 @@ export type AdminReportIndexData = {
         /**
          * Number of results per page
          */
-        size?: number;
+        limit?: number;
         /**
          * Filter by report status
          */
@@ -4366,11 +4671,19 @@ export type AdminReportIndexData = {
         /**
          * Filter by target type
          */
-        targetType?: 'SEGMENT' | 'EPISODE' | 'MEDIA';
+        'target.type'?: 'SEGMENT' | 'EPISODE' | 'MEDIA';
         /**
          * Filter by target media ID
          */
-        targetMediaId?: number;
+        'target.mediaId'?: number;
+        /**
+         * Filter by target episode number
+         */
+        'target.episodeNumber'?: number;
+        /**
+         * Filter by target segment UUID
+         */
+        'target.segmentUuid'?: string;
         /**
          * Filter by review check run ID
          */
@@ -4378,7 +4691,7 @@ export type AdminReportIndexData = {
     };
     url: '/v1/admin/reports';
 };
-export type AdminReportIndexErrors = {
+export type ListAdminReportsErrors = {
     /**
      * Unauthorized
      */
@@ -4396,15 +4709,15 @@ export type AdminReportIndexErrors = {
      */
     500: Error500;
 };
-export type AdminReportIndexError = AdminReportIndexErrors[keyof AdminReportIndexErrors];
-export type AdminReportIndexResponses = {
+export type ListAdminReportsError = ListAdminReportsErrors[keyof ListAdminReportsErrors];
+export type ListAdminReportsResponses = {
     /**
      * OK
      */
     200: AdminReportListResponse;
 };
-export type AdminReportIndexResponse = AdminReportIndexResponses[keyof AdminReportIndexResponses];
-export type AdminReportUpdateData = {
+export type ListAdminReportsResponse = ListAdminReportsResponses[keyof ListAdminReportsResponses];
+export type UpdateAdminReportData = {
     body: UpdateReportRequest;
     path: {
         /**
@@ -4415,7 +4728,7 @@ export type AdminReportUpdateData = {
     query?: never;
     url: '/v1/admin/reports/{id}';
 };
-export type AdminReportUpdateErrors = {
+export type UpdateAdminReportErrors = {
     /**
      * Bad Request
      */
@@ -4441,15 +4754,15 @@ export type AdminReportUpdateErrors = {
      */
     500: Error500;
 };
-export type AdminReportUpdateError = AdminReportUpdateErrors[keyof AdminReportUpdateErrors];
-export type AdminReportUpdateResponses = {
+export type UpdateAdminReportError = UpdateAdminReportErrors[keyof UpdateAdminReportErrors];
+export type UpdateAdminReportResponses = {
     /**
      * Report updated successfully
      */
     200: Report;
 };
-export type AdminReportUpdateResponse = AdminReportUpdateResponses[keyof AdminReportUpdateResponses];
-export type AdminReviewRunCreateData = {
+export type UpdateAdminReportResponse = UpdateAdminReportResponses[keyof UpdateAdminReportResponses];
+export type RunAdminReviewData = {
     body?: never;
     path?: never;
     query?: {
@@ -4457,10 +4770,14 @@ export type AdminReviewRunCreateData = {
          * Optional category filter
          */
         category?: 'ANIME' | 'JDRAMA';
+        /**
+         * Optional check name to run a single check instead of all
+         */
+        checkName?: string;
     };
     url: '/v1/admin/review/run';
 };
-export type AdminReviewRunCreateErrors = {
+export type RunAdminReviewErrors = {
     /**
      * Unauthorized
      */
@@ -4478,21 +4795,21 @@ export type AdminReviewRunCreateErrors = {
      */
     500: Error500;
 };
-export type AdminReviewRunCreateError = AdminReviewRunCreateErrors[keyof AdminReviewRunCreateErrors];
-export type AdminReviewRunCreateResponses = {
+export type RunAdminReviewError = RunAdminReviewErrors[keyof RunAdminReviewErrors];
+export type RunAdminReviewResponses = {
     /**
      * Check run completed
      */
     200: RunReviewResponse;
 };
-export type AdminReviewRunCreateResponse = AdminReviewRunCreateResponses[keyof AdminReviewRunCreateResponses];
-export type AdminReviewCheckIndexData = {
+export type RunAdminReviewResponse = RunAdminReviewResponses[keyof RunAdminReviewResponses];
+export type ListAdminReviewChecksData = {
     body?: never;
     path?: never;
     query?: never;
     url: '/v1/admin/review/checks';
 };
-export type AdminReviewCheckIndexErrors = {
+export type ListAdminReviewChecksErrors = {
     /**
      * Unauthorized
      */
@@ -4510,15 +4827,15 @@ export type AdminReviewCheckIndexErrors = {
      */
     500: Error500;
 };
-export type AdminReviewCheckIndexError = AdminReviewCheckIndexErrors[keyof AdminReviewCheckIndexErrors];
-export type AdminReviewCheckIndexResponses = {
+export type ListAdminReviewChecksError = ListAdminReviewChecksErrors[keyof ListAdminReviewChecksErrors];
+export type ListAdminReviewChecksResponses = {
     /**
      * OK
      */
     200: Array<ReviewCheck>;
 };
-export type AdminReviewCheckIndexResponse = AdminReviewCheckIndexResponses[keyof AdminReviewCheckIndexResponses];
-export type AdminReviewCheckUpdateData = {
+export type ListAdminReviewChecksResponse = ListAdminReviewChecksResponses[keyof ListAdminReviewChecksResponses];
+export type UpdateAdminReviewCheckData = {
     body: {
         /**
          * New threshold values
@@ -4540,7 +4857,7 @@ export type AdminReviewCheckUpdateData = {
     query?: never;
     url: '/v1/admin/review/checks/{name}';
 };
-export type AdminReviewCheckUpdateErrors = {
+export type UpdateAdminReviewCheckErrors = {
     /**
      * Bad Request
      */
@@ -4566,15 +4883,15 @@ export type AdminReviewCheckUpdateErrors = {
      */
     500: Error500;
 };
-export type AdminReviewCheckUpdateError = AdminReviewCheckUpdateErrors[keyof AdminReviewCheckUpdateErrors];
-export type AdminReviewCheckUpdateResponses = {
+export type UpdateAdminReviewCheckError = UpdateAdminReviewCheckErrors[keyof UpdateAdminReviewCheckErrors];
+export type UpdateAdminReviewCheckResponses = {
     /**
      * Check updated successfully
      */
     200: ReviewCheck;
 };
-export type AdminReviewCheckUpdateResponse = AdminReviewCheckUpdateResponses[keyof AdminReviewCheckUpdateResponses];
-export type AdminReviewRunIndexData = {
+export type UpdateAdminReviewCheckResponse = UpdateAdminReviewCheckResponses[keyof UpdateAdminReviewCheckResponses];
+export type ListAdminReviewRunsData = {
     body?: never;
     path?: never;
     query?: {
@@ -4589,11 +4906,11 @@ export type AdminReviewRunIndexData = {
         /**
          * Number of results per page
          */
-        size?: number;
+        limit?: number;
     };
     url: '/v1/admin/review/runs';
 };
-export type AdminReviewRunIndexErrors = {
+export type ListAdminReviewRunsErrors = {
     /**
      * Unauthorized
      */
@@ -4611,19 +4928,18 @@ export type AdminReviewRunIndexErrors = {
      */
     500: Error500;
 };
-export type AdminReviewRunIndexError = AdminReviewRunIndexErrors[keyof AdminReviewRunIndexErrors];
-export type AdminReviewRunIndexResponses = {
+export type ListAdminReviewRunsError = ListAdminReviewRunsErrors[keyof ListAdminReviewRunsErrors];
+export type ListAdminReviewRunsResponses = {
     /**
      * OK
      */
     200: {
-        data: Array<ReviewCheckRun>;
-        hasMore: boolean;
-        cursor?: number;
+        runs: Array<ReviewCheckRun>;
+        pagination: CursorPagination;
     };
 };
-export type AdminReviewRunIndexResponse = AdminReviewRunIndexResponses[keyof AdminReviewRunIndexResponses];
-export type AdminReviewRunShowData = {
+export type ListAdminReviewRunsResponse = ListAdminReviewRunsResponses[keyof ListAdminReviewRunsResponses];
+export type GetAdminReviewRunData = {
     body?: never;
     path: {
         /**
@@ -4634,7 +4950,7 @@ export type AdminReviewRunShowData = {
     query?: never;
     url: '/v1/admin/review/runs/{id}';
 };
-export type AdminReviewRunShowErrors = {
+export type GetAdminReviewRunErrors = {
     /**
      * Unauthorized
      */
@@ -4656,8 +4972,8 @@ export type AdminReviewRunShowErrors = {
      */
     500: Error500;
 };
-export type AdminReviewRunShowError = AdminReviewRunShowErrors[keyof AdminReviewRunShowErrors];
-export type AdminReviewRunShowResponses = {
+export type GetAdminReviewRunError = GetAdminReviewRunErrors[keyof GetAdminReviewRunErrors];
+export type GetAdminReviewRunResponses = {
     /**
      * OK
      */
@@ -4666,8 +4982,8 @@ export type AdminReviewRunShowResponses = {
         reports: Array<Report>;
     };
 };
-export type AdminReviewRunShowResponse = AdminReviewRunShowResponses[keyof AdminReviewRunShowResponses];
-export type AdminReviewAllowlistIndexData = {
+export type GetAdminReviewRunResponse = GetAdminReviewRunResponses[keyof GetAdminReviewRunResponses];
+export type ListAdminReviewAllowlistData = {
     body?: never;
     path?: never;
     query?: {
@@ -4678,7 +4994,7 @@ export type AdminReviewAllowlistIndexData = {
     };
     url: '/v1/admin/review/allowlist';
 };
-export type AdminReviewAllowlistIndexErrors = {
+export type ListAdminReviewAllowlistErrors = {
     /**
      * Unauthorized
      */
@@ -4696,15 +5012,15 @@ export type AdminReviewAllowlistIndexErrors = {
      */
     500: Error500;
 };
-export type AdminReviewAllowlistIndexError = AdminReviewAllowlistIndexErrors[keyof AdminReviewAllowlistIndexErrors];
-export type AdminReviewAllowlistIndexResponses = {
+export type ListAdminReviewAllowlistError = ListAdminReviewAllowlistErrors[keyof ListAdminReviewAllowlistErrors];
+export type ListAdminReviewAllowlistResponses = {
     /**
      * OK
      */
     200: Array<ReviewAllowlist>;
 };
-export type AdminReviewAllowlistIndexResponse = AdminReviewAllowlistIndexResponses[keyof AdminReviewAllowlistIndexResponses];
-export type AdminReviewAllowlistCreateData = {
+export type ListAdminReviewAllowlistResponse = ListAdminReviewAllowlistResponses[keyof ListAdminReviewAllowlistResponses];
+export type CreateAdminReviewAllowlistEntryData = {
     body: {
         /**
          * Check name to allowlist for
@@ -4727,7 +5043,7 @@ export type AdminReviewAllowlistCreateData = {
     query?: never;
     url: '/v1/admin/review/allowlist';
 };
-export type AdminReviewAllowlistCreateErrors = {
+export type CreateAdminReviewAllowlistEntryErrors = {
     /**
      * Bad Request
      */
@@ -4753,15 +5069,15 @@ export type AdminReviewAllowlistCreateErrors = {
      */
     500: Error500;
 };
-export type AdminReviewAllowlistCreateError = AdminReviewAllowlistCreateErrors[keyof AdminReviewAllowlistCreateErrors];
-export type AdminReviewAllowlistCreateResponses = {
+export type CreateAdminReviewAllowlistEntryError = CreateAdminReviewAllowlistEntryErrors[keyof CreateAdminReviewAllowlistEntryErrors];
+export type CreateAdminReviewAllowlistEntryResponses = {
     /**
      * Added to allowlist
      */
     201: ReviewAllowlist;
 };
-export type AdminReviewAllowlistCreateResponse = AdminReviewAllowlistCreateResponses[keyof AdminReviewAllowlistCreateResponses];
-export type AdminReviewAllowlistDestroyData = {
+export type CreateAdminReviewAllowlistEntryResponse = CreateAdminReviewAllowlistEntryResponses[keyof CreateAdminReviewAllowlistEntryResponses];
+export type DeleteAdminReviewAllowlistEntryData = {
     body?: never;
     path: {
         /**
@@ -4772,7 +5088,7 @@ export type AdminReviewAllowlistDestroyData = {
     query?: never;
     url: '/v1/admin/review/allowlist/{id}';
 };
-export type AdminReviewAllowlistDestroyErrors = {
+export type DeleteAdminReviewAllowlistEntryErrors = {
     /**
      * Unauthorized
      */
@@ -4794,12 +5110,12 @@ export type AdminReviewAllowlistDestroyErrors = {
      */
     500: Error500;
 };
-export type AdminReviewAllowlistDestroyError = AdminReviewAllowlistDestroyErrors[keyof AdminReviewAllowlistDestroyErrors];
-export type AdminReviewAllowlistDestroyResponses = {
+export type DeleteAdminReviewAllowlistEntryError = DeleteAdminReviewAllowlistEntryErrors[keyof DeleteAdminReviewAllowlistEntryErrors];
+export type DeleteAdminReviewAllowlistEntryResponses = {
     /**
      * Removed from allowlist
      */
     204: void;
 };
-export type AdminReviewAllowlistDestroyResponse = AdminReviewAllowlistDestroyResponses[keyof AdminReviewAllowlistDestroyResponses];
+export type DeleteAdminReviewAllowlistEntryResponse = DeleteAdminReviewAllowlistEntryResponses[keyof DeleteAdminReviewAllowlistEntryResponses];
 //# sourceMappingURL=types.gen.d.ts.map