@brigadasos/nadeshiko-sdk 1.4.0-dev.2819d72 → 1.4.0-dev.28a0384

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;
-    ja: JapaneseSearchContent;
-    en: TranslationSearchContent;
-    es: 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;
+    /**
+     * Total number of episodes available
+     */
+    episodeCount: number;
+    /**
+     * Animation studio that produced the media
+     */
+    studio: string;
     /**
-     * Media information for this result
+     * 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 = {
+export type SearchStatsRequest = {
     /**
-     * Text or sentence to search (null to search without query)
+     * What to search for (omit for queryless stats)
      */
-    query?: string;
+    query?: {
+        /**
+         * Search expression (supports boolean operators, wildcards, phrase matching)
+         */
+        search?: string;
+        /**
+         * Whether to use exact phrase matching
+         */
+        exactMatch?: boolean;
+    };
+    filters?: SearchFilters;
     /**
-     * Max amount of entries by response
-     */
-    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;
-        /**
-         * Array of episode numbers
-         */
-        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;
-    };
-};
-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>;
-    /**
-     * 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
      */
@@ -780,175 +813,24 @@ export type Media = {
      */
     seasonYear: number;
     /**
-     * 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)
+     * Base path for R2/CDN storage (e.g. "media/21459")
      */
-    cursor?: number;
+    storageBasePath?: string;
     /**
-     * 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
-     */
-    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;
-    /**
-     * 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
+     * A short, human-readable summary of the problem
      */
     title: string;
     /**
@@ -1075,13 +957,13 @@ export type MediaUpdateRequest = {
      */
     seasonYear?: number;
     /**
-     * List of characters appearing in the media with their voice actors
+     * Base path for R2/CDN storage (e.g. "media/21459")
      */
-    characters?: Array<CharacterInput>;
+    storageBasePath?: string;
     /**
-     * Lists to add this media to (e.g., series, franchise)
+     * List of characters appearing in the media with their voice actors
      */
-    lists?: Array<ListInput>;
+    characters?: Array<CharacterInput>;
     /**
      * Total number of subtitle segments available
      */
@@ -1133,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 = {
     /**
@@ -1210,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;
-    ja: JapaneseContent;
-    en: TranslationContent;
-    es: 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
@@ -1325,20 +1095,20 @@ 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;
-    ja: {
+    endTimeMs: number;
+    textJa: {
         /**
          * Original Japanese content of the segment
          */
         content?: string;
     };
-    es?: {
+    textEs?: {
         /**
          * Spanish translation of the segment content
          */
@@ -1348,7 +1118,7 @@ export type SegmentCreateRequest = {
          */
         isMachineTranslated?: boolean;
     };
-    en?: {
+    textEn?: {
         /**
          * English translation of the segment content
          */
@@ -1358,10 +1128,19 @@ export type SegmentCreateRequest = {
          */
         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
      */
@@ -1371,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
  */
@@ -1384,20 +1192,20 @@ 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;
-    ja?: {
+    endTimeMs?: number;
+    textJa?: {
         /**
          * Original Japanese content of the segment
          */
         content?: string;
     };
-    es?: {
+    textEs?: {
         /**
          * Spanish translation of the segment content
          */
@@ -1407,7 +1215,7 @@ export type SegmentUpdateRequest = {
          */
         isMachineTranslated?: boolean;
     };
-    en?: {
+    textEn?: {
         /**
          * English translation of the segment content
          */
@@ -1417,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
      */
@@ -1431,28 +1248,97 @@ 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
+     */
+    nameRomaji: string;
+    /**
+     * English name of the series
      */
     nameEn: string;
+};
+export type SeriesListResponse = {
+    series: Array<Series>;
+    pagination: CursorPagination;
+};
+/**
+ * Series with ordered media entries
+ */
+export type SeriesWithMedia = {
     /**
-     * Character image URL
+     * Series ID
      */
-    imageUrl: string;
+    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
@@ -1466,7 +1352,7 @@ export type CharacterWithMedia = {
     }>;
 };
 /**
- * Seiyuu with all voice acting roles
+ * Seiyuu details with optional character appearances
  */
 export type SeiyuuWithRoles = {
     /**
@@ -1486,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 = {
@@ -1523,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 = {
+    /**
+     * Report target type
+     */
+    type: 'EPISODE';
+    /**
+     * Media ID this report targets
+     */
+    mediaId: number;
+    /**
+     * Episode number this report targets
+     */
+    episodeNumber: number;
+};
+export type ReportTargetSegment = {
     /**
-     * What level the report targets
+     * Report target type
      */
-    targetType: 'SEGMENT' | 'EPISODE' | 'MEDIA';
+    type: 'SEGMENT';
     /**
      * Media ID this report targets
      */
-    targetMediaId: number;
+    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 = {
     /**
-     * Episode number (for EPISODE/SEGMENT targets)
+     * Report ID
      */
-    targetEpisodeNumber?: number;
+    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)
      */
@@ -1588,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
      */
@@ -1631,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
@@ -1650,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)
-     */
-    userId: number;
-    /**
-     * Visibility of the list
+     * Visibility of the collection
      */
-    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';
     /**
@@ -1753,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
@@ -1846,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 = {
     /**
@@ -2001,38 +1947,6 @@ export type ReviewAllowlist = {
      */
     createdAt: string;
 };
-export type HealthCheckData = {
-    body?: never;
-    path?: never;
-    query?: never;
-    url: '/v1/health';
-};
-export type HealthCheckErrors = {
-    /**
-     * Unauthorized
-     */
-    401: Error401;
-    /**
-     * Forbidden
-     */
-    403: Error403;
-    /**
-     * Too Many Requests
-     */
-    429: Error429;
-    /**
-     * Internal Server Error
-     */
-    500: Error500;
-};
-export type HealthCheckError = HealthCheckErrors[keyof HealthCheckErrors];
-export type HealthCheckResponses = {
-    /**
-     * OK
-     */
-    200: SearchHealthCheckResponse;
-};
-export type HealthCheckResponse = HealthCheckResponses[keyof HealthCheckResponses];
 export type SearchIndexData = {
     body?: SearchRequest;
     path?: never;
@@ -2154,17 +2068,398 @@ export type MediaIndexData = {
          */
         cursor?: number;
         /**
-         * Filter by media category
+         * 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 MediaIndexErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type MediaIndexError = MediaIndexErrors[keyof MediaIndexErrors];
+export type MediaIndexResponses = {
+    /**
+     * OK
+     */
+    200: MediaListResponse;
+};
+export type MediaIndexResponse = MediaIndexResponses[keyof MediaIndexResponses];
+export type MediaCreateData = {
+    body: MediaCreateRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/media';
+};
+export type MediaCreateErrors = {
+    /**
+     * 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 MediaCreateError = MediaCreateErrors[keyof MediaCreateErrors];
+export type MediaCreateResponses = {
+    /**
+     * Created
+     */
+    201: Media;
+};
+export type MediaCreateResponse = MediaCreateResponses[keyof MediaCreateResponses];
+export type MediaDestroyData = {
+    body?: never;
+    path: {
+        /**
+         * Media ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/media/{id}';
+};
+export type MediaDestroyErrors = {
+    /**
+     * 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 MediaDestroyError = MediaDestroyErrors[keyof MediaDestroyErrors];
+export type MediaDestroyResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type MediaDestroyResponse = MediaDestroyResponses[keyof MediaDestroyResponses];
+export type MediaShowData = {
+    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 MediaShowErrors = {
+    /**
+     * 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 MediaShowError = MediaShowErrors[keyof MediaShowErrors];
+export type MediaShowResponses = {
+    /**
+     * OK
+     */
+    200: Media;
+};
+export type MediaShowResponse = MediaShowResponses[keyof MediaShowResponses];
+export type MediaUpdateData = {
+    body: MediaUpdateRequest;
+    path: {
+        /**
+         * Media ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/media/{id}';
+};
+export type MediaUpdateErrors = {
+    /**
+     * 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 MediaUpdateError = MediaUpdateErrors[keyof MediaUpdateErrors];
+export type MediaUpdateResponses = {
+    /**
+     * OK
+     */
+    200: Media;
+};
+export type MediaUpdateResponse = MediaUpdateResponses[keyof MediaUpdateResponses];
+export type EpisodeIndexData = {
+    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 EpisodeIndexErrors = {
+    /**
+     * 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 EpisodeIndexError = EpisodeIndexErrors[keyof EpisodeIndexErrors];
+export type EpisodeIndexResponses = {
+    /**
+     * Paginated list of episodes
+     */
+    200: EpisodeListResponse;
+};
+export type EpisodeIndexResponse = EpisodeIndexResponses[keyof EpisodeIndexResponses];
+export type EpisodeCreateData = {
+    body: EpisodeCreateRequest;
+    path: {
+        /**
+         * ID of the media
+         */
+        mediaId: number;
+    };
+    query?: never;
+    url: '/v1/media/{mediaId}/episodes';
+};
+export type EpisodeCreateErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Conflict
+     */
+    409: Error409;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type EpisodeCreateError = EpisodeCreateErrors[keyof EpisodeCreateErrors];
+export type EpisodeCreateResponses = {
+    /**
+     * Single episode response
+     */
+    201: Episode;
+};
+export type EpisodeCreateResponse = EpisodeCreateResponses[keyof EpisodeCreateResponses];
+export type EpisodeDestroyData = {
+    body?: never;
+    path: {
+        /**
+         * ID of the media
+         */
+        mediaId: number;
+        /**
+         * Episode number
+         */
+        episodeNumber: number;
+    };
+    query?: never;
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}';
+};
+export type EpisodeDestroyErrors = {
+    /**
+     * 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 EpisodeDestroyError = EpisodeDestroyErrors[keyof EpisodeDestroyErrors];
+export type EpisodeDestroyResponses = {
+    /**
+     * Episode successfully deleted
+     */
+    204: void;
+};
+export type EpisodeDestroyResponse = EpisodeDestroyResponses[keyof EpisodeDestroyResponses];
+export type EpisodeShowData = {
+    body?: never;
+    path: {
+        /**
+         * 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 EpisodeShowErrors = {
     /**
      * Bad Request
      */
@@ -2177,6 +2472,10 @@ export type MediaIndexErrors = {
      * Forbidden
      */
     403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
     /**
      * Too Many Requests
      */
@@ -2186,21 +2485,30 @@ export type MediaIndexErrors = {
      */
     500: Error500;
 };
-export type MediaIndexError = MediaIndexErrors[keyof MediaIndexErrors];
-export type MediaIndexResponses = {
+export type EpisodeShowError = EpisodeShowErrors[keyof EpisodeShowErrors];
+export type EpisodeShowResponses = {
     /**
-     * OK
+     * Single episode response
      */
-    200: MediaListResponse;
+    200: Episode;
 };
-export type MediaIndexResponse = MediaIndexResponses[keyof MediaIndexResponses];
-export type MediaCreateData = {
-    body: MediaCreateRequest;
-    path?: never;
+export type EpisodeShowResponse = EpisodeShowResponses[keyof EpisodeShowResponses];
+export type EpisodeUpdateData = {
+    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 EpisodeUpdateErrors = {
     /**
      * Bad Request
      */
@@ -2214,9 +2522,9 @@ export type MediaCreateErrors = {
      */
     403: Error403;
     /**
-     * Conflict
+     * Not Found
      */
-    409: Error409;
+    404: Error404;
     /**
      * Too Many Requests
      */
@@ -2226,26 +2534,39 @@ export type MediaCreateErrors = {
      */
     500: Error500;
 };
-export type MediaCreateError = MediaCreateErrors[keyof MediaCreateErrors];
-export type MediaCreateResponses = {
+export type EpisodeUpdateError = EpisodeUpdateErrors[keyof EpisodeUpdateErrors];
+export type EpisodeUpdateResponses = {
     /**
-     * Created
+     * Single episode response
      */
-    201: Media;
+    200: Episode;
 };
-export type MediaCreateResponse = MediaCreateResponses[keyof MediaCreateResponses];
-export type MediaDestroyData = {
+export type EpisodeUpdateResponse = EpisodeUpdateResponses[keyof EpisodeUpdateResponses];
+export type SegmentIndexData = {
     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 SegmentIndexErrors = {
     /**
      * Bad Request
      */
@@ -2271,29 +2592,36 @@ export type MediaDestroyErrors = {
      */
     500: Error500;
 };
-export type MediaDestroyError = MediaDestroyErrors[keyof MediaDestroyErrors];
-export type MediaDestroyResponses = {
+export type SegmentIndexError = SegmentIndexErrors[keyof SegmentIndexErrors];
+export type SegmentIndexResponses = {
     /**
-     * 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 SegmentIndexResponse = SegmentIndexResponses[keyof SegmentIndexResponses];
+export type SegmentCreateData = {
+    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 SegmentCreateErrors = {
     /**
      * Bad Request
      */
@@ -2310,6 +2638,10 @@ export type MediaShowErrors = {
      * Not Found
      */
     404: Error404;
+    /**
+     * Conflict
+     */
+    409: Error409;
     /**
      * Too Many Requests
      */
@@ -2319,26 +2651,34 @@ export type MediaShowErrors = {
      */
     500: Error500;
 };
-export type MediaShowError = MediaShowErrors[keyof MediaShowErrors];
-export type MediaShowResponses = {
+export type SegmentCreateError = SegmentCreateErrors[keyof SegmentCreateErrors];
+export type SegmentCreateResponses = {
     /**
-     * OK
+     * Single segment response with internal fields
      */
-    200: Media;
+    201: SegmentInternal;
 };
-export type MediaShowResponse = MediaShowResponses[keyof MediaShowResponses];
-export type MediaUpdateData = {
-    body: MediaUpdateRequest;
+export type SegmentCreateResponse = SegmentCreateResponses[keyof SegmentCreateResponses];
+export type SegmentDestroyData = {
+    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 SegmentDestroyErrors = {
     /**
      * Bad Request
      */
@@ -2364,35 +2704,34 @@ export type MediaUpdateErrors = {
      */
     500: Error500;
 };
-export type MediaUpdateError = MediaUpdateErrors[keyof MediaUpdateErrors];
-export type MediaUpdateResponses = {
+export type SegmentDestroyError = SegmentDestroyErrors[keyof SegmentDestroyErrors];
+export type SegmentDestroyResponses = {
     /**
-     * OK
+     * Segment successfully deleted
      */
-    200: Media;
+    204: void;
 };
-export type MediaUpdateResponse = MediaUpdateResponses[keyof MediaUpdateResponses];
-export type EpisodeIndexData = {
+export type SegmentDestroyResponse = SegmentDestroyResponses[keyof SegmentDestroyResponses];
+export type SegmentShowData = {
     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 SegmentShowErrors = {
     /**
      * Bad Request
      */
@@ -2418,26 +2757,34 @@ export type EpisodeIndexErrors = {
      */
     500: Error500;
 };
-export type EpisodeIndexError = EpisodeIndexErrors[keyof EpisodeIndexErrors];
-export type EpisodeIndexResponses = {
+export type SegmentShowError = SegmentShowErrors[keyof SegmentShowErrors];
+export type SegmentShowResponses = {
     /**
-     * Paginated list of episodes
+     * Single segment response
      */
-    200: EpisodeListResponse;
+    200: Segment;
 };
-export type EpisodeIndexResponse = EpisodeIndexResponses[keyof EpisodeIndexResponses];
-export type EpisodeCreateData = {
-    body: EpisodeCreateRequest;
+export type SegmentShowResponse = SegmentShowResponses[keyof SegmentShowResponses];
+export type SegmentUpdateData = {
+    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 SegmentUpdateErrors = {
     /**
      * Bad Request
      */
@@ -2454,10 +2801,6 @@ export type EpisodeCreateErrors = {
      * Not Found
      */
     404: Error404;
-    /**
-     * Conflict
-     */
-    409: Error409;
     /**
      * Too Many Requests
      */
@@ -2467,30 +2810,26 @@ export type EpisodeCreateErrors = {
      */
     500: Error500;
 };
-export type EpisodeCreateError = EpisodeCreateErrors[keyof EpisodeCreateErrors];
-export type EpisodeCreateResponses = {
+export type SegmentUpdateError = SegmentUpdateErrors[keyof SegmentUpdateErrors];
+export type SegmentUpdateResponses = {
     /**
-     * Single episode response
+     * Single segment response with internal fields
      */
-    201: Episode;
+    200: SegmentInternal;
 };
-export type EpisodeCreateResponse = EpisodeCreateResponses[keyof EpisodeCreateResponses];
-export type EpisodeDestroyData = {
+export type SegmentUpdateResponse = SegmentUpdateResponses[keyof SegmentUpdateResponses];
+export type SegmentShowByUuidData = {
     body?: never;
     path: {
         /**
-         * ID of the media
-         */
-        mediaId: number;
-        /**
-         * 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 SegmentShowByUuidErrors = {
     /**
      * Bad Request
      */
@@ -2516,30 +2855,36 @@ export type EpisodeDestroyErrors = {
      */
     500: Error500;
 };
-export type EpisodeDestroyError = EpisodeDestroyErrors[keyof EpisodeDestroyErrors];
-export type EpisodeDestroyResponses = {
-    /**
-     * Episode successfully deleted
-     */
-    204: void;
+export type SegmentShowByUuidError = SegmentShowByUuidErrors[keyof SegmentShowByUuidErrors];
+export type SegmentShowByUuidResponses = {
+    200: Segment;
 };
-export type EpisodeDestroyResponse = EpisodeDestroyResponses[keyof EpisodeDestroyResponses];
-export type EpisodeShowData = {
+export type SegmentShowByUuidResponse = SegmentShowByUuidResponses[keyof SegmentShowByUuidResponses];
+export type SegmentContextShowData = {
     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
+         */
+        limit?: number;
+        /**
+         * Content ratings to include (omit for all ratings)
+         */
+        contentRating?: Array<ContentRating>;
+        /**
+         * Resources to expand in the response includes block
          */
-        episodeNumber: number;
+        include?: Array<IncludeExpansion>;
     };
-    query?: never;
-    url: '/v1/media/{mediaId}/episodes/{episodeNumber}';
+    url: '/v1/media/segments/{uuid}/context';
 };
-export type EpisodeShowErrors = {
+export type SegmentContextShowErrors = {
     /**
      * Bad Request
      */
@@ -2565,30 +2910,34 @@ export type EpisodeShowErrors = {
      */
     500: Error500;
 };
-export type EpisodeShowError = EpisodeShowErrors[keyof EpisodeShowErrors];
-export type EpisodeShowResponses = {
+export type SegmentContextShowError = SegmentContextShowErrors[keyof SegmentContextShowErrors];
+export type SegmentContextShowResponses = {
     /**
-     * Single episode response
+     * OK
      */
-    200: Episode;
+    200: SegmentContextResponse;
 };
-export type EpisodeShowResponse = EpisodeShowResponses[keyof EpisodeShowResponses];
-export type EpisodeUpdateData = {
-    body: EpisodeUpdateRequest;
-    path: {
+export type SegmentContextShowResponse = SegmentContextShowResponses[keyof SegmentContextShowResponses];
+export type SeriesIndexData = {
+    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 SeriesIndexErrors = {
     /**
      * Bad Request
      */
@@ -2601,10 +2950,6 @@ export type EpisodeUpdateErrors = {
      * Forbidden
      */
     403: Error403;
-    /**
-     * Not Found
-     */
-    404: Error404;
     /**
      * Too Many Requests
      */
@@ -2614,39 +2959,34 @@ export type EpisodeUpdateErrors = {
      */
     500: Error500;
 };
-export type EpisodeUpdateError = EpisodeUpdateErrors[keyof EpisodeUpdateErrors];
-export type EpisodeUpdateResponses = {
+export type SeriesIndexError = SeriesIndexErrors[keyof SeriesIndexErrors];
+export type SeriesIndexResponses = {
     /**
-     * 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 SeriesIndexResponse = SeriesIndexResponses[keyof SeriesIndexResponses];
+export type SeriesCreateData = {
+    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 SeriesCreateErrors = {
     /**
      * Bad Request
      */
@@ -2659,10 +2999,6 @@ export type SegmentIndexErrors = {
      * Forbidden
      */
     403: Error403;
-    /**
-     * Not Found
-     */
-    404: Error404;
     /**
      * Too Many Requests
      */
@@ -2672,30 +3008,26 @@ export type SegmentIndexErrors = {
      */
     500: Error500;
 };
-export type SegmentIndexError = SegmentIndexErrors[keyof SegmentIndexErrors];
-export type SegmentIndexResponses = {
+export type SeriesCreateError = SeriesCreateErrors[keyof SeriesCreateErrors];
+export type SeriesCreateResponses = {
     /**
-     * Paginated list of segments
+     * Created
      */
-    200: SegmentListResponse;
+    201: Series;
 };
-export type SegmentIndexResponse = SegmentIndexResponses[keyof SegmentIndexResponses];
-export type SegmentCreateData = {
-    body: SegmentCreateRequest;
+export type SeriesCreateResponse = SeriesCreateResponses[keyof SeriesCreateResponses];
+export type SeriesDestroyData = {
+    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 SeriesDestroyErrors = {
     /**
      * Bad Request
      */
@@ -2712,10 +3044,6 @@ export type SegmentCreateErrors = {
      * Not Found
      */
     404: Error404;
-    /**
-     * Conflict
-     */
-    409: Error409;
     /**
      * Too Many Requests
      */
@@ -2725,34 +3053,31 @@ export type SegmentCreateErrors = {
      */
     500: Error500;
 };
-export type SegmentCreateError = SegmentCreateErrors[keyof SegmentCreateErrors];
-export type SegmentCreateResponses = {
+export type SeriesDestroyError = SeriesDestroyErrors[keyof SeriesDestroyErrors];
+export type SeriesDestroyResponses = {
     /**
-     * Single segment response
+     * No Content
      */
-    201: Segment;
+    204: void;
 };
-export type SegmentCreateResponse = SegmentCreateResponses[keyof SegmentCreateResponses];
-export type SegmentDestroyData = {
+export type SeriesDestroyResponse = SeriesDestroyResponses[keyof SeriesDestroyResponses];
+export type SeriesShowData = {
     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 SeriesShowErrors = {
     /**
      * Bad Request
      */
@@ -2778,34 +3103,39 @@ export type SegmentDestroyErrors = {
      */
     500: Error500;
 };
-export type SegmentDestroyError = SegmentDestroyErrors[keyof SegmentDestroyErrors];
-export type SegmentDestroyResponses = {
+export type SeriesShowError = SeriesShowErrors[keyof SeriesShowErrors];
+export type SeriesShowResponses = {
     /**
-     * Segment successfully deleted
+     * OK
      */
-    204: void;
+    200: SeriesWithMedia;
 };
-export type SegmentDestroyResponse = SegmentDestroyResponses[keyof SegmentDestroyResponses];
-export type SegmentShowData = {
-    body?: never;
-    path: {
+export type SeriesShowResponse = SeriesShowResponses[keyof SeriesShowResponses];
+export type SeriesUpdateData = {
+    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 SeriesUpdateErrors = {
     /**
      * Bad Request
      */
@@ -2831,34 +3161,35 @@ export type SegmentShowErrors = {
      */
     500: Error500;
 };
-export type SegmentShowError = SegmentShowErrors[keyof SegmentShowErrors];
-export type SegmentShowResponses = {
+export type SeriesUpdateError = SeriesUpdateErrors[keyof SeriesUpdateErrors];
+export type SeriesUpdateResponses = {
     /**
-     * Single segment response
+     * OK
      */
-    200: Segment;
+    200: Series;
 };
-export type SegmentShowResponse = SegmentShowResponses[keyof SegmentShowResponses];
-export type SegmentUpdateData = {
-    body: SegmentUpdateRequest;
-    path: {
+export type SeriesUpdateResponse = SeriesUpdateResponses[keyof SeriesUpdateResponses];
+export type SeriesAddMediaData = {
+    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 SeriesAddMediaErrors = {
     /**
      * Bad Request
      */
@@ -2884,26 +3215,30 @@ export type SegmentUpdateErrors = {
      */
     500: Error500;
 };
-export type SegmentUpdateError = SegmentUpdateErrors[keyof SegmentUpdateErrors];
-export type SegmentUpdateResponses = {
+export type SeriesAddMediaError = SeriesAddMediaErrors[keyof SeriesAddMediaErrors];
+export type SeriesAddMediaResponses = {
     /**
-     * Single segment response
+     * No Content
      */
-    200: Segment;
+    204: void;
 };
-export type SegmentUpdateResponse = SegmentUpdateResponses[keyof SegmentUpdateResponses];
-export type SegmentShowByUuidData = {
+export type SeriesAddMediaResponse = SeriesAddMediaResponses[keyof SeriesAddMediaResponses];
+export type SeriesRemoveMediaData = {
     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 SeriesRemoveMediaErrors = {
     /**
      * Bad Request
      */
@@ -2929,28 +3264,35 @@ export type SegmentShowByUuidErrors = {
      */
     500: Error500;
 };
-export type SegmentShowByUuidError = SegmentShowByUuidErrors[keyof SegmentShowByUuidErrors];
-export type SegmentShowByUuidResponses = {
-    200: Segment;
+export type SeriesRemoveMediaError = SeriesRemoveMediaErrors[keyof SeriesRemoveMediaErrors];
+export type SeriesRemoveMediaResponses = {
+    /**
+     * No Content
+     */
+    204: void;
 };
-export type SegmentShowByUuidResponse = SegmentShowByUuidResponses[keyof SegmentShowByUuidResponses];
-export type SegmentContextShowData = {
-    body?: never;
-    path: {
+export type SeriesRemoveMediaResponse = SeriesRemoveMediaResponses[keyof SeriesRemoveMediaResponses];
+export type SeriesUpdateMediaData = {
+    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 SeriesUpdateMediaErrors = {
     /**
      * Bad Request
      */
@@ -2976,14 +3318,14 @@ export type SegmentContextShowErrors = {
      */
     500: Error500;
 };
-export type SegmentContextShowError = SegmentContextShowErrors[keyof SegmentContextShowErrors];
-export type SegmentContextShowResponses = {
+export type SeriesUpdateMediaError = SeriesUpdateMediaErrors[keyof SeriesUpdateMediaErrors];
+export type SeriesUpdateMediaResponses = {
     /**
-     * OK
+     * No Content
      */
-    200: SegmentContextResponse;
+    204: void;
 };
-export type SegmentContextShowResponse = SegmentContextShowResponses[keyof SegmentContextShowResponses];
+export type SeriesUpdateMediaResponse = SeriesUpdateMediaResponses[keyof SeriesUpdateMediaResponses];
 export type CharacterShowData = {
     body?: never;
     path: {
@@ -3037,7 +3379,12 @@ 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 = {
@@ -3085,6 +3432,10 @@ export type UserQuotaShowErrors = {
      * Unauthorized
      */
     401: Error401;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
     /**
      * Internal Server Error
      */
@@ -3109,7 +3460,7 @@ export type UserReportIndexData = {
         /**
          * Number of results per page
          */
-        size?: number;
+        limit?: number;
         /**
          * Filter by report status
          */
@@ -3258,11 +3609,15 @@ 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';
 };
@@ -3282,16 +3637,60 @@ export type UserActivityIndexResponses = {
      * OK
      */
     200: {
-        data: Array<UserActivity>;
-        hasMore: boolean;
-        cursor?: number;
+        activities: Array<UserActivity>;
+        pagination: CursorPagination;
     };
 };
 export type UserActivityIndexResponse = UserActivityIndexResponses[keyof UserActivityIndexResponses];
+export type UserActivityHeatmapShowData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Number of days to include in the heatmap
+         */
+        days?: number;
+        /**
+         * Filter by activity type
+         */
+        activityType?: ActivityType;
+    };
+    url: '/v1/user/activity/heatmap';
+};
+export type UserActivityHeatmapShowErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type UserActivityHeatmapShowError = UserActivityHeatmapShowErrors[keyof UserActivityHeatmapShowErrors];
+export type UserActivityHeatmapShowResponses = {
+    /**
+     * OK
+     */
+    200: {
+        /**
+         * Map of YYYY-MM-DD date strings to activity counts
+         */
+        counts: {
+            [key: string]: number;
+        };
+    };
+};
+export type UserActivityHeatmapShowResponse = UserActivityHeatmapShowResponses[keyof UserActivityHeatmapShowResponses];
 export type UserActivityStatsShowData = {
     body?: never;
     path?: never;
-    query?: never;
+    query?: {
+        /**
+         * Only count activities from this date onward (YYYY-MM-DD)
+         */
+        since?: string;
+    };
     url: '/v1/user/activity/stats';
 };
 export type UserActivityStatsShowErrors = {
@@ -3346,45 +3745,34 @@ export type UserExportShowResponses = {
     /**
      * 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;
-        }>;
-    };
+    200: UserExportResponse;
 };
 export type UserExportShowResponse = UserExportShowResponses[keyof UserExportShowResponses];
-export type LabIndexData = {
+export type UserLabsIndexData = {
     body?: never;
     path?: never;
     query?: never;
-    url: '/v1/labs';
+    url: '/v1/user/labs';
 };
-export type LabIndexErrors = {
+export type UserLabsIndexErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
     /**
      * Internal Server Error
      */
     500: Error500;
 };
-export type LabIndexError = LabIndexErrors[keyof LabIndexErrors];
-export type LabIndexResponses = {
+export type UserLabsIndexError = UserLabsIndexErrors[keyof UserLabsIndexErrors];
+export type UserLabsIndexResponses = {
     /**
      * OK
      */
-    200: Array<LabFeature>;
+    200: Array<UserLabFeature>;
 };
-export type LabIndexResponse = LabIndexResponses[keyof LabIndexResponses];
-export type ListIndexData = {
+export type UserLabsIndexResponse = UserLabsIndexResponses[keyof UserLabsIndexResponses];
+export type CollectionIndexData = {
     body?: never;
     path?: never;
     query?: {
@@ -3393,21 +3781,23 @@ export type ListIndexData = {
          */
         visibility?: 'public' | 'private';
         /**
-         * Filter by list type
+         * Cursor offset for pagination
          */
-        type?: 'SERIES' | 'CUSTOM' | 'SEGMENT';
+        cursor?: number;
         /**
-         * Filter by list owner user ID
+         * Page number (1-indexed)
+         *
+         * @deprecated
          */
-        userId?: number;
+        page?: number;
         /**
-         * Filter lists containing this media ID
+         * Items per page
          */
-        mediaId?: number;
+        limit?: number;
     };
-    url: '/v1/lists';
+    url: '/v1/collections';
 };
-export type ListIndexErrors = {
+export type CollectionIndexErrors = {
     /**
      * Bad Request
      */
@@ -3429,21 +3819,21 @@ export type ListIndexErrors = {
      */
     500: Error500;
 };
-export type ListIndexError = ListIndexErrors[keyof ListIndexErrors];
-export type ListIndexResponses = {
+export type CollectionIndexError = CollectionIndexErrors[keyof CollectionIndexErrors];
+export type CollectionIndexResponses = {
     /**
      * OK
      */
-    200: Array<List>;
+    200: CollectionListResponse;
 };
-export type ListIndexResponse = ListIndexResponses[keyof ListIndexResponses];
-export type ListCreateData = {
-    body: ListCreateRequest;
+export type CollectionIndexResponse = CollectionIndexResponses[keyof CollectionIndexResponses];
+export type CollectionCreateData = {
+    body: CollectionRequests;
     path?: never;
     query?: never;
-    url: '/v1/lists';
+    url: '/v1/collections';
 };
-export type ListCreateErrors = {
+export type CollectionCreateErrors = {
     /**
      * Bad Request
      */
@@ -3465,26 +3855,26 @@ export type ListCreateErrors = {
      */
     500: Error500;
 };
-export type ListCreateError = ListCreateErrors[keyof ListCreateErrors];
-export type ListCreateResponses = {
+export type CollectionCreateError = CollectionCreateErrors[keyof CollectionCreateErrors];
+export type CollectionCreateResponses = {
     /**
      * Created
      */
-    201: List;
+    201: Collection;
 };
-export type ListCreateResponse = ListCreateResponses[keyof ListCreateResponses];
-export type ListDestroyData = {
+export type CollectionCreateResponse = CollectionCreateResponses[keyof CollectionCreateResponses];
+export type CollectionDestroyData = {
     body?: never;
     path: {
         /**
-         * List ID
+         * Collection ID
          */
         id: number;
     };
     query?: never;
-    url: '/v1/lists/{id}';
+    url: '/v1/collections/{id}';
 };
-export type ListDestroyErrors = {
+export type CollectionDestroyErrors = {
     /**
      * Bad Request
      */
@@ -3510,128 +3900,41 @@ export type ListDestroyErrors = {
      */
     500: Error500;
 };
-export type ListDestroyError = ListDestroyErrors[keyof ListDestroyErrors];
-export type ListDestroyResponses = {
+export type CollectionDestroyError = CollectionDestroyErrors[keyof CollectionDestroyErrors];
+export type CollectionDestroyResponses = {
     /**
-     * OK
+     * No Content
      */
-    200: {
-        message?: string;
-        id?: number;
-    };
+    204: void;
 };
-export type ListDestroyResponse = ListDestroyResponses[keyof ListDestroyResponses];
-export type ListShowData = {
+export type CollectionDestroyResponse = CollectionDestroyResponses[keyof CollectionDestroyResponses];
+export type CollectionShowData = {
     body?: never;
     path: {
         /**
-         * List ID
+         * Collection ID
          */
         id: number;
     };
-    query?: never;
-    url: '/v1/lists/{id}';
-};
-export type ListShowErrors = {
-    /**
-     * 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 ListShowError = ListShowErrors[keyof ListShowErrors];
-export type ListShowResponses = {
-    /**
-     * OK
-     */
-    200: ListWithMedia;
-};
-export type ListShowResponse = ListShowResponses[keyof ListShowResponses];
-export type ListUpdateData = {
-    body: {
-        name?: string;
-        visibility?: 'PUBLIC' | 'PRIVATE';
-    };
-    path: {
+    query?: {
         /**
-         * List ID
+         * Cursor offset for paginated segments
          */
-        id: number;
-    };
-    query?: never;
-    url: '/v1/lists/{id}';
-};
-export type ListUpdateErrors = {
-    /**
-     * 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 ListUpdateError = ListUpdateErrors[keyof ListUpdateErrors];
-export type ListUpdateResponses = {
-    /**
-     * OK
-     */
-    200: List;
-};
-export type ListUpdateResponse = ListUpdateResponses[keyof ListUpdateResponses];
-export type ListAddItemData = {
-    body: {
-        mediaId: number;
+        cursor?: number;
         /**
-         * Position in the list (1-indexed)
+         * Page number (1-indexed)
+         *
+         * @deprecated
          */
-        position: number;
-    };
-    path: {
+        page?: number;
         /**
-         * List ID
+         * Items per page
          */
-        id: number;
+        limit?: number;
     };
-    query?: never;
-    url: '/v1/lists/{id}/items';
+    url: '/v1/collections/{id}';
 };
-export type ListAddItemErrors = {
+export type CollectionShowErrors = {
     /**
      * Bad Request
      */
@@ -3648,10 +3951,6 @@ export type ListAddItemErrors = {
      * Not Found
      */
     404: Error404;
-    /**
-     * Conflict
-     */
-    409: Error409;
     /**
      * Too Many Requests
      */
@@ -3661,32 +3960,29 @@ export type ListAddItemErrors = {
      */
     500: Error500;
 };
-export type ListAddItemError = ListAddItemErrors[keyof ListAddItemErrors];
-export type ListAddItemResponses = {
+export type CollectionShowError = CollectionShowErrors[keyof CollectionShowErrors];
+export type CollectionShowResponses = {
     /**
-     * Created
+     * OK
      */
-    201: {
-        message?: string;
-    };
+    200: CollectionWithSegments;
 };
-export type ListAddItemResponse = ListAddItemResponses[keyof ListAddItemResponses];
-export type ListRemoveItemData = {
-    body?: never;
+export type CollectionShowResponse = CollectionShowResponses[keyof CollectionShowResponses];
+export type CollectionUpdateData = {
+    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 CollectionUpdateErrors = {
     /**
      * Bad Request
      */
@@ -3712,37 +4008,35 @@ export type ListRemoveItemErrors = {
      */
     500: Error500;
 };
-export type ListRemoveItemError = ListRemoveItemErrors[keyof ListRemoveItemErrors];
-export type ListRemoveItemResponses = {
+export type CollectionUpdateError = CollectionUpdateErrors[keyof CollectionUpdateErrors];
+export type CollectionUpdateResponses = {
     /**
      * OK
      */
-    200: {
-        message?: string;
-    };
+    200: Collection;
 };
-export type ListRemoveItemResponse = ListRemoveItemResponses[keyof ListRemoveItemResponses];
-export type ListUpdateItemData = {
+export type CollectionUpdateResponse = CollectionUpdateResponses[keyof CollectionUpdateResponses];
+export type CollectionAddSegmentData = {
     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 CollectionAddSegmentErrors = {
     /**
      * Bad Request
      */
@@ -3768,37 +4062,30 @@ export type ListUpdateItemErrors = {
      */
     500: Error500;
 };
-export type ListUpdateItemError = ListUpdateItemErrors[keyof ListUpdateItemErrors];
-export type ListUpdateItemResponses = {
+export type CollectionAddSegmentError = CollectionAddSegmentErrors[keyof CollectionAddSegmentErrors];
+export type CollectionAddSegmentResponses = {
     /**
-     * OK
+     * No Content
      */
-    200: {
-        message?: string;
-    };
+    204: void;
 };
-export type ListUpdateItemResponse = ListUpdateItemResponses[keyof ListUpdateItemResponses];
-export type ListGetSegmentsData = {
+export type CollectionAddSegmentResponse = CollectionAddSegmentResponses[keyof CollectionAddSegmentResponses];
+export type CollectionRemoveSegmentData = {
     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 CollectionRemoveSegmentErrors = {
     /**
      * Bad Request
      */
@@ -3824,35 +4111,39 @@ export type ListGetSegmentsErrors = {
      */
     500: Error500;
 };
-export type ListGetSegmentsError = ListGetSegmentsErrors[keyof ListGetSegmentsErrors];
-export type ListGetSegmentsResponses = {
+export type CollectionRemoveSegmentError = CollectionRemoveSegmentErrors[keyof CollectionRemoveSegmentErrors];
+export type CollectionRemoveSegmentResponses = {
     /**
-     * OK
+     * No Content
      */
-    200: ListWithSegments;
+    204: void;
 };
-export type ListGetSegmentsResponse = ListGetSegmentsResponses[keyof ListGetSegmentsResponses];
-export type ListAddSegmentData = {
+export type CollectionRemoveSegmentResponse = CollectionRemoveSegmentResponses[keyof CollectionRemoveSegmentResponses];
+export type CollectionUpdateSegmentData = {
     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 CollectionUpdateSegmentErrors = {
     /**
      * Bad Request
      */
@@ -3869,10 +4160,6 @@ export type ListAddSegmentErrors = {
      * Not Found
      */
     404: Error404;
-    /**
-     * Conflict
-     */
-    409: Error409;
     /**
      * Too Many Requests
      */
@@ -3882,36 +4169,21 @@ export type ListAddSegmentErrors = {
      */
     500: Error500;
 };
-export type ListAddSegmentError = ListAddSegmentErrors[keyof ListAddSegmentErrors];
-export type ListAddSegmentResponses = {
+export type CollectionUpdateSegmentError = CollectionUpdateSegmentErrors[keyof CollectionUpdateSegmentErrors];
+export type CollectionUpdateSegmentResponses = {
     /**
-     * Created
+     * No Content
      */
-    201: {
-        message?: string;
-    };
+    204: void;
 };
-export type ListAddSegmentResponse = ListAddSegmentResponses[keyof ListAddSegmentResponses];
-export type ListRemoveSegmentData = {
+export type CollectionUpdateSegmentResponse = CollectionUpdateSegmentResponses[keyof CollectionUpdateSegmentResponses];
+export type AdminDashboardShowData = {
     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 AdminDashboardShowErrors = {
     /**
      * Unauthorized
      */
@@ -3920,10 +4192,6 @@ export type ListRemoveSegmentErrors = {
      * Forbidden
      */
     403: Error403;
-    /**
-     * Not Found
-     */
-    404: Error404;
     /**
      * Too Many Requests
      */
@@ -3933,45 +4201,81 @@ export type ListRemoveSegmentErrors = {
      */
     500: Error500;
 };
-export type ListRemoveSegmentError = ListRemoveSegmentErrors[keyof ListRemoveSegmentErrors];
-export type ListRemoveSegmentResponses = {
+export type AdminDashboardShowError = AdminDashboardShowErrors[keyof AdminDashboardShowErrors];
+export type AdminDashboardShowResponses = {
     /**
      * 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 AdminDashboardShowResponse = AdminDashboardShowResponses[keyof AdminDashboardShowResponses];
+export type AdminHealthShowData = {
+    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 AdminHealthShowErrors = {
     /**
      * Unauthorized
      */
@@ -3980,10 +4284,6 @@ export type ListUpdateSegmentErrors = {
      * Forbidden
      */
     403: Error403;
-    /**
-     * Not Found
-     */
-    404: Error404;
     /**
      * Too Many Requests
      */
@@ -3993,16 +4293,40 @@ export type ListUpdateSegmentErrors = {
      */
     500: Error500;
 };
-export type ListUpdateSegmentError = ListUpdateSegmentErrors[keyof ListUpdateSegmentErrors];
-export type ListUpdateSegmentResponses = {
+export type AdminHealthShowError = AdminHealthShowErrors[keyof AdminHealthShowErrors];
+export type AdminHealthShowResponses = {
     /**
      * 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 AdminHealthShowResponse = AdminHealthShowResponses[keyof AdminHealthShowResponses];
 export type AdminReindexCreateData = {
     body?: ReindexRequest;
     path?: never;
@@ -4128,31 +4452,45 @@ export type AdminQueueShowResponses = {
      * 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];
@@ -4310,27 +4648,6 @@ export type AdminQueueFailedDestroyResponses = {
     };
 };
 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 = {
     body?: never;
     path?: never;
@@ -4342,7 +4659,7 @@ export type AdminReportIndexData = {
         /**
          * Number of results per page
          */
-        size?: number;
+        limit?: number;
         /**
          * Filter by report status
          */
@@ -4354,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
          */
@@ -4445,6 +4770,10 @@ 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';
 };
@@ -4577,7 +4906,7 @@ export type AdminReviewRunIndexData = {
         /**
          * Number of results per page
          */
-        size?: number;
+        limit?: number;
     };
     url: '/v1/admin/review/runs';
 };
@@ -4605,9 +4934,8 @@ export type AdminReviewRunIndexResponses = {
      * OK
      */
     200: {
-        data: Array<ReviewCheckRun>;
-        hasMore: boolean;
-        cursor?: number;
+        runs: Array<ReviewCheckRun>;
+        pagination: CursorPagination;
     };
 };
 export type AdminReviewRunIndexResponse = AdminReviewRunIndexResponses[keyof AdminReviewRunIndexResponses];