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

package/dist/types.gen.d.ts

@@ -0,0 +1,4793 @@
+export type ClientOptions = {
+    baseUrl: 'http://localhost:5000' | 'https://api.nadeshiko.co' | (string & {});
+};
+/**
+ * Media category type
+ */
+export type Category = 'ANIME' | 'JDRAMA';
+/**
+ * Media information included in search results
+ */
+export type SearchResultMedia = {
+    /**
+     * Unique identifier for the media
+     */
+    mediaId: number;
+    /**
+     * Romaji transliteration of the media name
+     */
+    nameRomaji: string;
+    /**
+     * English name of the media
+     */
+    nameEn?: string;
+    /**
+     * Original Japanese name of the media
+     */
+    nameJa?: string;
+    /**
+     * URL to the cover image
+     */
+    coverUrl?: string;
+    /**
+     * URL to the banner image
+     */
+    bannerUrl?: string;
+    category: Category;
+};
+/**
+ * Japanese content in search results with optional highlight
+ */
+export type JapaneseSearchContent = {
+    /**
+     * Original Japanese content of the segment
+     */
+    content: string;
+    /**
+     * Japanese content with search terms highlighted
+     */
+    highlight?: string;
+};
+/**
+ * Translation content in search results with optional highlight
+ */
+export type TranslationSearchContent = {
+    /**
+     * Translated content
+     */
+    content?: string;
+    /**
+     * Translated content with search terms highlighted
+     */
+    highlight?: string;
+    /**
+     * Whether the translation was machine-translated
+     */
+    isMachineTranslated: boolean;
+};
+/**
+ * Morphological analysis token
+ */
+export type Morpheme = {
+    /**
+     * Surface form of the token as it appears in the text
+     */
+    surface: string;
+    /**
+     * Reading in katakana
+     */
+    reading: string;
+    /**
+     * Dictionary/base form of the word
+     */
+    baseform: string;
+    /**
+     * Pronunciation in katakana
+     */
+    pronunciation: string;
+    /**
+     * Full part-of-speech tag array
+     */
+    pos: Array<string>;
+    /**
+     * Short part-of-speech label (first element of pos array)
+     */
+    posShort: string;
+    /**
+     * Character offset where the token begins in the original text
+     */
+    begin: number;
+    /**
+     * Character offset where the token ends in the original text
+     */
+    end: number;
+    /**
+     * 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.
+     *
+     */
+    pitchAccentType: Array<number>;
+    /**
+     * Compound accent connection rule from UniDic feature[25]. Values like C1-C5, F1-F6, P1-P13. Null if not available.
+     *
+     */
+    pitchCompoundRule: string;
+    /**
+     * Accent modification rule from UniDic feature[26]. Values like M1, M2, M4. Null if not available.
+     *
+     */
+    pitchModificationRule: string;
+};
+/**
+ * Segment details in search results
+ */
+export type SearchResultSegment = {
+    /**
+     * Segment status
+     */
+    status: 'DELETED' | 'ACTIVE' | 'SUSPENDED' | 'VERIFIED' | 'INVALID' | 'TOO_LONG';
+    /**
+     * Unique identifier for the segment
+     */
+    uuid: string;
+    /**
+     * Position of the segment within the episode
+     */
+    position: number;
+    /**
+     * 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;
+    /**
+     * Episode number where the segment appears
+     */
+    episodeNumber: number;
+    ja: JapaneseSearchContent;
+    en: TranslationSearchContent;
+    es: TranslationSearchContent;
+    /**
+     * Whether the segment contains NSFW content
+     */
+    isNsfw: boolean;
+    /**
+     * Morphological analysis of the Japanese content
+     */
+    morphemes?: Array<Morpheme>;
+};
+/**
+ * URLs to media resources for a segment
+ */
+export type SearchResultUrls = {
+    /**
+     * 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;
+};
+/**
+ * A complete search result combining media info, segment details, and URLs
+ */
+export type SearchResult = {
+    /**
+     * Media information for this result
+     */
+    media: SearchResultMedia;
+    /**
+     * Segment details including translations
+     */
+    segment: SearchResultSegment;
+    /**
+     * URLs to media resources (images, audio, video)
+     */
+    urls: SearchResultUrls;
+};
+/**
+ * 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
+     */
+    hasMore?: boolean;
+    /**
+     * Estimated total number of matching segments
+     */
+    estimatedTotalHits?: number;
+    /**
+     * Whether estimatedTotalHits is exact or a lower bound
+     */
+    estimatedTotalHitsRelation?: 'EXACT' | 'LOWER_BOUND';
+};
+export type SearchHealthCheckResponse = {
+    results?: Array<SearchResult>;
+    pagination?: PaginationInfo;
+    /**
+     * Cursor for pagination
+     */
+    cursor?: Array<number>;
+};
+/**
+ * Unauthorized error response
+ */
+export type Error401 = {
+    /**
+     * Specific error code for programmatic handling
+     */
+    code: 'AUTH_CREDENTIALS_REQUIRED' | 'AUTH_CREDENTIALS_INVALID' | 'AUTH_CREDENTIALS_EXPIRED' | 'EMAIL_NOT_VERIFIED';
+    /**
+     * 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: 401;
+    /**
+     * Optional map of field names to their error messages (for validation errors)
+     */
+    errors?: {
+        [key: string]: string;
+    };
+};
+/**
+ * Forbidden error response
+ */
+export type Error403 = {
+    /**
+     * Specific error code for programmatic handling
+     */
+    code: 'ACCESS_DENIED' | 'INSUFFICIENT_PERMISSIONS';
+    /**
+     * 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: 403;
+    /**
+     * Optional map of field names to their error messages (for validation errors)
+     */
+    errors?: {
+        [key: string]: string;
+    };
+};
+/**
+ * Too Many Requests error response
+ */
+export type Error429 = {
+    /**
+     * Specific error code for programmatic handling
+     */
+    code: 'RATE_LIMIT_EXCEEDED' | 'QUOTA_EXCEEDED';
+    /**
+     * 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: 429;
+    /**
+     * Optional map of field names to their error messages (for validation errors)
+     */
+    errors?: {
+        [key: string]: string;
+    };
+};
+/**
+ * Internal Server Error response
+ */
+export type Error500 = {
+    /**
+     * Specific error code for programmatic handling
+     */
+    code: 'INTERNAL_SERVER_EXCEPTION';
+    /**
+     * 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: 500;
+    /**
+     * Optional map of field names to their error messages (for validation errors)
+     */
+    errors?: {
+        [key: string]: string;
+    };
+};
+export type SearchRequest = {
+    /**
+     * Text or sentence to search (null to search without query)
+     */
+    query?: string;
+    /**
+     * 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
+     */
+    status?: Array<'DELETED' | 'ACTIVE' | 'SUSPENDED' | 'VERIFIED' | 'INVALID' | 'TOO_LONG'>;
+};
+/**
+ * Search result statistics grouped by 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
+     */
+    nameJa?: string;
+    /**
+     * Total number of segments found for this media
+     */
+    segmentCount?: number;
+    /**
+     * Mapping of episode numbers to segment hit counts
+     */
+    episodeHits?: {
+        [key: string]: number;
+    };
+};
+/**
+ * Count of entries grouped by media category
+ */
+export type CategoryCount = {
+    category?: Category;
+    /**
+     * Number of entries in this category
+     */
+    count?: number;
+};
+export type SearchStatsResponse = {
+    media?: Array<MediaSearchStats>;
+    categories?: Array<CategoryCount>;
+};
+export type SearchMultipleRequest = {
+    /**
+     * List of words to search for
+     */
+    words: Array<string>;
+    /**
+     * Whether to use exact matching
+     */
+    exactMatch?: boolean;
+};
+/**
+ * Media entry containing word matches
+ */
+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
+     */
+    nameRomaji?: string;
+    /**
+     * Number of times the word appears in this media
+     */
+    matchCount?: number;
+};
+/**
+ * Word matching result with occurrences across media
+ */
+export type WordMatch = {
+    /**
+     * The word that was searched for
+     */
+    word?: string;
+    /**
+     * Indicates whether the word was found in any segment
+     */
+    isMatch?: boolean;
+    /**
+     * Total number of times this word appears across all media
+     */
+    matchCount?: number;
+    /**
+     * List of media containing this word
+     */
+    media?: Array<WordMatchMedia>;
+};
+export type SearchMultipleResponse = {
+    results?: Array<WordMatch>;
+};
+/**
+ * Map of external IDs keyed by source. Only sources with values are included.
+ */
+export type ExternalId = {
+    /**
+     * AniList ID
+     */
+    anilist?: string;
+    /**
+     * IMDB ID
+     */
+    imdb?: string;
+    /**
+     * TVDB ID
+     */
+    tvdb?: string;
+};
+/**
+ * Japanese voice actor (seiyuu)
+ */
+export type Seiyuu = {
+    /**
+     * AniList staff ID
+     */
+    id: number;
+    /**
+     * Japanese name of the voice actor
+     */
+    nameJa: string;
+    /**
+     * English name of the voice actor
+     */
+    nameEn: string;
+    /**
+     * Profile image URL
+     */
+    imageUrl: string;
+};
+/**
+ * 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;
+    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
+     */
+    name: string;
+    /**
+     * Type of list
+     */
+    type: 'SERIES' | 'CUSTOM' | 'SEGMENT';
+    /**
+     * User ID who owns the list (1 = admin)
+     */
+    userId: number;
+    /**
+     * Visibility of the list
+     */
+    visibility: 'PUBLIC' | 'PRIVATE';
+};
+/**
+ * Media entry with full metadata
+ */
+export type Media = {
+    /**
+     * Unique identifier for the media
+     */
+    id: number;
+    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>;
+    /**
+     * 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;
+    /**
+     * Version identifier for the media entry
+     */
+    version: string;
+    /**
+     * Animation studio that produced the media
+     */
+    studio: string;
+    /**
+     * Airing season label for the media
+     */
+    seasonName: string;
+    /**
+     * Airing year for the 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)
+     */
+    cursor?: number;
+    /**
+     * Whether more results are available
+     */
+    hasMoreResults: boolean;
+};
+/**
+ * Character data for creating/updating media
+ */
+export type CharacterInput = {
+    /**
+     * 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'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
+     */
+    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: 409;
+    /**
+     * Optional map of field names to their error messages (for validation errors)
+     */
+    errors?: {
+        [key: string]: string;
+    };
+};
+/**
+ * Not Found error response
+ */
+export type Error404 = {
+    /**
+     * Specific error code for programmatic handling
+     */
+    code: 'NOT_FOUND';
+    /**
+     * 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: 404;
+    /**
+     * Optional map of field names to their error messages (for validation errors)
+     */
+    errors?: {
+        [key: string]: string;
+    };
+};
+/**
+ * Request body for updating an existing media entry (all fields optional)
+ */
+export type MediaUpdateRequest = {
+    externalIds?: ExternalId;
+    /**
+     * Original Japanese name of the media
+     */
+    nameJa?: string;
+    /**
+     * Romaji transliteration of the media name
+     */
+    nameRomaji?: string;
+    /**
+     * English name of the media
+     */
+    nameEn?: string;
+    /**
+     * Format of the media release (e.g., TV, OVA, Movie)
+     */
+    airingFormat?: string;
+    /**
+     * Current airing status (FINISHED, RELEASING, NOT_YET_RELEASED, CANCELLED)
+     */
+    airingStatus?: string;
+    /**
+     * List of genres associated with the media
+     */
+    genres?: Array<string>;
+    /**
+     * Storage backend for media assets
+     */
+    storage?: 'LOCAL' | 'R2';
+    /**
+     * Start date of the media (first airing/release)
+     */
+    startDate?: string;
+    /**
+     * End date of the media (last airing/release)
+     */
+    endDate?: string;
+    /**
+     * Media category
+     */
+    category?: 'ANIME' | 'JDRAMA';
+    /**
+     * Version of the media-sub-splitter used
+     */
+    version?: string;
+    /**
+     * Hash salt used when generating the hash for the related media assets
+     */
+    hashSalt?: string;
+    /**
+     * Animation studio that produced the media
+     */
+    studio?: string;
+    /**
+     * Airing season label for the media
+     */
+    seasonName?: string;
+    /**
+     * Airing year for the media
+     */
+    seasonYear?: number;
+    /**
+     * List of characters appearing in the media with their voice actors
+     */
+    characters?: Array<CharacterInput>;
+    /**
+     * Lists to add this media to (e.g., series, franchise)
+     */
+    lists?: Array<ListInput>;
+    /**
+     * Total number of subtitle segments available
+     */
+    segmentCount?: number;
+};
+export type Episode = {
+    /**
+     * ID of the media this episode belongs to
+     */
+    mediaId: number;
+    /**
+     * Episode number within the media
+     */
+    episodeNumber: number;
+    /**
+     * English title of the episode
+     */
+    titleEn?: string;
+    /**
+     * Romanized title of the episode
+     */
+    titleRomaji?: string;
+    /**
+     * Japanese title of the episode
+     */
+    titleJa?: string;
+    /**
+     * Episode description or synopsis
+     */
+    description?: string;
+    /**
+     * When the episode originally aired
+     */
+    airedAt?: string;
+    /**
+     * Episode duration in seconds
+     */
+    lengthSeconds?: number;
+    /**
+     * URL to episode thumbnail image
+     */
+    thumbnailUrl?: string;
+    /**
+     * Number of segments in this episode
+     */
+    segmentCount: number;
+};
+export type EpisodeListResponse = {
+    /**
+     * Array of episode objects
+     */
+    data: Array<Episode>;
+    /**
+     * Cursor for pagination (last episode number in current page)
+     */
+    cursor?: number;
+    /**
+     * Whether more results are available
+     */
+    hasMore: boolean;
+};
+export type EpisodeCreateRequest = {
+    /**
+     * English title of the episode
+     */
+    titleEn?: string;
+    /**
+     * Romanized title of the episode
+     */
+    titleRomaji?: string;
+    /**
+     * Japanese title of the episode
+     */
+    titleJa?: string;
+    /**
+     * Episode description or synopsis
+     */
+    description?: string;
+    /**
+     * When the episode originally aired
+     */
+    airedAt?: string;
+    /**
+     * Episode duration in seconds
+     */
+    lengthSeconds?: number;
+    /**
+     * URL to episode thumbnail image
+     */
+    thumbnailUrl?: string;
+    /**
+     * Episode number within the media (must be unique for this media)
+     */
+    episodeNumber: number;
+};
+/**
+ * All fields are optional for partial updates
+ */
+export type EpisodeUpdateRequest = {
+    /**
+     * English title of the episode
+     */
+    titleEn?: string;
+    /**
+     * Romanized title of the episode
+     */
+    titleRomaji?: string;
+    /**
+     * Japanese title of the episode
+     */
+    titleJa?: string;
+    /**
+     * Episode description or synopsis
+     */
+    description?: string;
+    /**
+     * When the episode originally aired
+     */
+    airedAt?: string;
+    /**
+     * Episode duration in seconds
+     */
+    lengthSeconds?: number;
+    /**
+     * URL to episode thumbnail image
+     */
+    thumbnailUrl?: string;
+};
+/**
+ * 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
+     */
+    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: {
+        /**
+         * Original Japanese content of the segment
+         */
+        content?: string;
+    };
+    es?: {
+        /**
+         * Spanish translation of the segment content
+         */
+        content?: string;
+        /**
+         * Whether the Spanish translation was machine-translated
+         */
+        isMachineTranslated?: boolean;
+    };
+    en?: {
+        /**
+         * English translation of the segment content
+         */
+        content?: string;
+        /**
+         * Whether the English translation was machine-translated
+         */
+        isMachineTranslated?: boolean;
+    };
+    /**
+     * Whether the segment contains NSFW content
+     */
+    isNsfw?: boolean;
+    /**
+     * Storage backend for segment assets
+     */
+    storage: 'LOCAL' | 'R2';
+    /**
+     * Hash identifier for the segment (from segment JSON)
+     */
+    hashedId: string;
+};
+/**
+ * All fields are optional for partial updates
+ */
+export type SegmentUpdateRequest = {
+    /**
+     * Position of the segment within the episode
+     */
+    position?: number;
+    /**
+     * Segment status
+     */
+    status?: 'DELETED' | 'ACTIVE' | 'SUSPENDED' | 'VERIFIED' | 'INVALID' | 'TOO_LONG';
+    /**
+     * 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?: {
+        /**
+         * Original Japanese content of the segment
+         */
+        content?: string;
+    };
+    es?: {
+        /**
+         * Spanish translation of the segment content
+         */
+        content?: string;
+        /**
+         * Whether the Spanish translation was machine-translated
+         */
+        isMachineTranslated?: boolean;
+    };
+    en?: {
+        /**
+         * English translation of the segment content
+         */
+        content?: string;
+        /**
+         * Whether the English translation was machine-translated
+         */
+        isMachineTranslated?: boolean;
+    };
+    /**
+     * Whether the segment contains NSFW content
+     */
+    isNsfw?: boolean;
+    /**
+     * Storage backend for segment assets
+     */
+    storage?: 'LOCAL' | 'R2';
+    /**
+     * Hash identifier for the segment (from segment JSON)
+     */
+    hashedId?: string;
+};
+export type SegmentContextResponse = {
+    segments: Array<SearchResult>;
+};
+/**
+ * Character with all media appearances
+ */
+export type CharacterWithMedia = {
+    /**
+     * AniList character ID
+     */
+    id: number;
+    /**
+     * Japanese name of the character
+     */
+    nameJa: string;
+    /**
+     * English name of the character
+     */
+    nameEn: string;
+    /**
+     * Character image URL
+     */
+    imageUrl: string;
+    seiyuu: Seiyuu;
+    /**
+     * All media this character appears in
+     */
+    mediaAppearances: Array<{
+        media?: Media;
+        /**
+         * Character role in this media
+         */
+        role?: 'MAIN' | 'SUPPORTING' | 'BACKGROUND';
+    }>;
+};
+/**
+ * Seiyuu with all voice acting roles
+ */
+export type SeiyuuWithRoles = {
+    /**
+     * AniList staff ID
+     */
+    id: number;
+    /**
+     * Japanese name of the voice actor
+     */
+    nameJa: string;
+    /**
+     * English name of the voice actor
+     */
+    nameEn: string;
+    /**
+     * Profile image URL
+     */
+    imageUrl: string;
+    /**
+     * All characters voiced by this seiyuu with their media appearances
+     */
+    roles: Array<{
+        character?: Character;
+        media?: Media;
+        /**
+         * Character role in this media
+         */
+        role?: 'MAIN' | 'SUPPORTING' | 'BACKGROUND';
+    }>;
+};
+export type UserQuotaResponse = {
+    /**
+     * Number of API requests used in the current billing period.
+     */
+    quotaUsed: number;
+    /**
+     * Maximum number of API requests allowed in the current billing period.
+     */
+    quotaLimit: number;
+    /**
+     * Number of API requests remaining in the current billing period.
+     */
+    quotaRemaining: number;
+    /**
+     * Current billing period in YYYYMM format.
+     */
+    periodYyyymm: number;
+    /**
+     * Start of the current billing period (UTC).
+     */
+    periodStart: string;
+    /**
+     * End of the current billing period (UTC).
+     */
+    periodEnd: string;
+};
+export type Report = {
+    /**
+     * Report ID
+     */
+    id: number;
+    /**
+     * Who created this report
+     */
+    source: 'USER' | 'AUTO';
+    /**
+     * What level the report targets
+     */
+    targetType: 'SEGMENT' | 'EPISODE' | 'MEDIA';
+    /**
+     * Media ID this report targets
+     */
+    targetMediaId: number;
+    /**
+     * Episode number (for EPISODE/SEGMENT targets)
+     */
+    targetEpisodeNumber?: number;
+    /**
+     * Segment UUID (for SEGMENT targets)
+     */
+    targetSegmentUuid?: string;
+    /**
+     * ID of the auto-check run that created this report (AUTO only)
+     */
+    reviewCheckRunId?: number;
+    /**
+     * Reason for the report
+     */
+    reason: 'WRONG_TRANSLATION' | 'WRONG_TIMING' | 'WRONG_AUDIO' | 'NSFW_NOT_TAGGED' | 'DUPLICATE_SEGMENT' | 'WRONG_METADATA' | 'MISSING_EPISODES' | 'WRONG_COVER_IMAGE' | 'INAPPROPRIATE_CONTENT' | 'OTHER' | 'LOW_SEGMENT_MEDIA' | 'EMPTY_EPISODES' | 'MISSING_EPISODES_AUTO' | 'BAD_SEGMENT_RATIO' | 'MEDIA_WITH_NO_EPISODES' | 'MISSING_TRANSLATIONS' | 'DB_ES_SYNC_ISSUES' | 'HIGH_REPORT_DENSITY';
+    /**
+     * Optional description with additional details
+     */
+    description?: string;
+    /**
+     * Check-specific metrics (AUTO reports) or null (USER reports)
+     */
+    data?: {
+        [key: string]: unknown;
+    };
+    /**
+     * Current status of the report
+     */
+    status: 'PENDING' | 'CONCERN' | 'ACCEPTED' | 'REJECTED' | 'RESOLVED' | 'IGNORED';
+    /**
+     * Notes from the admin who reviewed the report
+     */
+    adminNotes?: string;
+    /**
+     * ID of the user who submitted the report (USER reports only)
+     */
+    userId?: number;
+    /**
+     * When the report was created
+     */
+    createdAt: string;
+    /**
+     * When the report was last updated
+     */
+    updatedAt?: string;
+};
+export type ReportListResponse = {
+    data: Array<Report>;
+    /**
+     * Whether more results are available
+     */
+    hasMore: boolean;
+    /**
+     * Cursor for next page
+     */
+    cursor?: number;
+};
+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;
+    /**
+     * Reason for the report
+     */
+    reason: 'WRONG_TRANSLATION' | 'WRONG_TIMING' | 'WRONG_AUDIO' | 'NSFW_NOT_TAGGED' | 'DUPLICATE_SEGMENT' | 'WRONG_METADATA' | 'MISSING_EPISODES' | 'WRONG_COVER_IMAGE' | 'INAPPROPRIATE_CONTENT' | 'OTHER';
+    /**
+     * Optional description with additional details
+     */
+    description?: string;
+};
+export type UserPreferences = {
+    /**
+     * Lab feature opt-in flags keyed by feature key
+     */
+    labs?: {
+        [key: string]: boolean;
+    };
+    /**
+     * Preferred language for media names display
+     */
+    mediaNameLanguage?: 'english' | 'japanese' | 'romaji';
+    searchHistory?: {
+        /**
+         * Whether activity tracking is enabled (default true)
+         */
+        enabled?: boolean;
+    };
+};
+/**
+ * Type of user activity
+ */
+export type ActivityType = 'SEARCH' | 'ANKI_EXPORT' | 'SEGMENT_PLAY' | 'LIST_ADD_SEGMENT';
+export type UserActivity = {
+    id: number;
+    activityType: ActivityType;
+    segmentUuid?: string;
+    mediaId?: number;
+    searchQuery?: string;
+    createdAt: string;
+};
+export type LabFeature = {
+    /**
+     * Unique identifier for the lab feature
+     */
+    key: string;
+    /**
+     * Human-readable feature name
+     */
+    name: string;
+    /**
+     * Description of what the feature does
+     */
+    description: string;
+    /**
+     * Whether the feature is globally available
+     */
+    enabled: boolean;
+};
+/**
+ * Request body for creating a new standalone list
+ */
+export type ListCreateRequest = {
+    /**
+     * Name of the list
+     */
+    name: string;
+    /**
+     * Type of list
+     */
+    type?: 'SERIES' | 'CUSTOM' | 'SEGMENT';
+    /**
+     * User ID who owns the list (1 = admin)
+     */
+    userId?: number;
+    /**
+     * Visibility of the list
+     */
+    visibility?: 'PUBLIC' | 'PRIVATE';
+};
+/**
+ * List with all media in order
+ */
+export type ListWithMedia = {
+    /**
+     * List ID
+     */
+    id: number;
+    /**
+     * Name of the list
+     */
+    name: string;
+    /**
+     * Type of list
+     */
+    type: 'SERIES' | 'CUSTOM' | 'SEGMENT';
+    /**
+     * User ID who owns the list (1 = admin)
+     */
+    userId: number;
+    /**
+     * Visibility of the list
+     */
+    visibility: 'PUBLIC' | 'PRIVATE';
+    /**
+     * All media in the list, sorted by position
+     */
+    media: Array<{
+        /**
+         * Position in the list (1-indexed)
+         */
+        position?: number;
+        media?: Media;
+    }>;
+};
+/**
+ * List with saved segments (search result format)
+ */
+export type ListWithSegments = {
+    /**
+     * List ID
+     */
+    id: number;
+    /**
+     * Name of the list
+     */
+    name: string;
+    /**
+     * Type of list
+     */
+    type: 'SERIES' | 'CUSTOM' | 'SEGMENT';
+    /**
+     * User ID who owns the list
+     */
+    userId: number;
+    /**
+     * Visibility of the list
+     */
+    visibility: 'PUBLIC' | 'PRIVATE';
+    /**
+     * Saved segments with their search result data
+     */
+    segments: Array<{
+        /**
+         * Position in the list
+         */
+        position?: number;
+        /**
+         * User annotation
+         */
+        note?: string;
+        result?: SearchResult;
+    }>;
+    /**
+     * Total number of segments in the list
+     */
+    totalCount: number;
+};
+/**
+ * Request to reindex segments from the database into Elasticsearch
+ */
+export type ReindexRequest = {
+    /**
+     * Array of media to reindex. If not provided, all media will be reindexed.
+     * Each media can optionally specify which episodes to reindex.
+     * If episodes are not specified for a media, all episodes will be reindexed.
+     */
+    media?: Array<{
+        /**
+         * The ID of the media
+         */
+        mediaId: number;
+        /**
+         * Optional array of episode numbers to reindex.
+         * If not provided, all episodes for this media will be reindexed.
+         */
+        episodes?: Array<number>;
+    }>;
+};
+/**
+ * Response from the reindex operation
+ */
+export type ReindexResponse = {
+    /**
+     * Whether the reindex operation completed successfully
+     */
+    success?: boolean;
+    /**
+     * Human-readable message about the reindex operation
+     */
+    message?: string;
+    /**
+     * Statistics about the reindex operation
+     */
+    stats?: {
+        /**
+         * Total number of segments processed
+         */
+        totalSegments?: number;
+        /**
+         * Number of segments successfully indexed
+         */
+        successfulIndexes?: number;
+        /**
+         * Number of segments that failed to index
+         */
+        failedIndexes?: number;
+        /**
+         * Number of media items processed
+         */
+        mediaProcessed?: number;
+    };
+    /**
+     * Array of errors that occurred during reindexing (if any)
+     */
+    errors?: Array<{
+        /**
+         * ID of the segment that failed
+         */
+        segmentId?: number;
+        /**
+         * Error message
+         */
+        error?: string;
+    }>;
+};
+export type AdminReport = Report & {
+    /**
+     * Number of reports for the same target
+     */
+    reportCount: number;
+    /**
+     * Name of the user who submitted this report
+     */
+    reporterName: string;
+};
+export type AdminReportListResponse = {
+    data: Array<AdminReport>;
+    /**
+     * Whether more results are available
+     */
+    hasMore: boolean;
+    /**
+     * Cursor for next page
+     */
+    cursor?: number;
+};
+export type UpdateReportRequest = {
+    /**
+     * New status for the report
+     */
+    status?: 'PENDING' | 'CONCERN' | 'ACCEPTED' | 'REJECTED' | 'RESOLVED' | 'IGNORED';
+    /**
+     * Admin notes about the report
+     */
+    adminNotes?: string;
+};
+export type RunReviewResponse = {
+    /**
+     * Category filter used
+     */
+    category: string;
+    checksRun: Array<{
+        /**
+         * Check identifier
+         */
+        checkName: string;
+        /**
+         * Human-readable check name
+         */
+        label: string;
+        /**
+         * Number of reports created
+         */
+        resultCount: number;
+        /**
+         * ID of the created run record
+         */
+        runId: number;
+    }>;
+    /**
+     * Total reports created across all checks
+     */
+    totalReports: number;
+};
+export type ReviewCheck = {
+    /**
+     * Check ID
+     */
+    id: number;
+    /**
+     * Unique check identifier
+     */
+    name: string;
+    /**
+     * Human-readable label
+     */
+    label: string;
+    /**
+     * What this check does
+     */
+    description: string;
+    /**
+     * What level this check operates on
+     */
+    targetType: 'MEDIA' | 'EPISODE';
+    /**
+     * Current threshold configuration
+     */
+    threshold: {
+        [key: string]: unknown;
+    };
+    /**
+     * Whether this check is active
+     */
+    enabled: boolean;
+    /**
+     * Schema for threshold fields (from registry)
+     */
+    thresholdSchema?: Array<{
+        key?: string;
+        label?: string;
+        type?: 'number' | 'boolean';
+        default?: number | boolean;
+        min?: number;
+        max?: number;
+    }>;
+    /**
+     * Latest run info for this check
+     */
+    latestRun?: {
+        id?: number;
+        resultCount?: number;
+        createdAt?: string;
+    };
+    createdAt?: string;
+    updatedAt?: string;
+};
+export type ReviewCheckRun = {
+    /**
+     * Run ID
+     */
+    id: number;
+    /**
+     * Name of the check that was run
+     */
+    checkName: string;
+    /**
+     * Category filter used (ANIME/JDRAMA) or null for all
+     */
+    category?: string;
+    /**
+     * Number of reports created in this run
+     */
+    resultCount: number;
+    /**
+     * Snapshot of threshold at run time
+     */
+    thresholdUsed: {
+        [key: string]: unknown;
+    };
+    /**
+     * When this run was executed
+     */
+    createdAt: string;
+};
+export type ReviewAllowlist = {
+    /**
+     * Allowlist entry ID
+     */
+    id: number;
+    /**
+     * Name of the check this entry applies to
+     */
+    checkName: string;
+    /**
+     * Media ID to exclude
+     */
+    mediaId: number;
+    /**
+     * Episode number to exclude (null for media-level checks)
+     */
+    episodeNumber?: number;
+    /**
+     * Why this was allowlisted
+     */
+    reason?: string;
+    /**
+     * When this entry was created
+     */
+    createdAt: string;
+};
+export type 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;
+    query?: never;
+    url: '/v1/search';
+};
+export type SearchIndexErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type SearchIndexError = SearchIndexErrors[keyof SearchIndexErrors];
+export type SearchIndexResponses = {
+    /**
+     * OK
+     */
+    200: SearchResponse;
+};
+export type SearchIndexResponse = SearchIndexResponses[keyof SearchIndexResponses];
+export type SearchStatsData = {
+    body?: SearchStatsRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/search/stats';
+};
+export type SearchStatsErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type SearchStatsError = SearchStatsErrors[keyof SearchStatsErrors];
+export type SearchStatsResponses = {
+    /**
+     * OK
+     */
+    200: SearchStatsResponse;
+};
+export type SearchStatsResponse2 = SearchStatsResponses[keyof SearchStatsResponses];
+export type SearchWordsData = {
+    body: SearchMultipleRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/search/words';
+};
+export type SearchWordsErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type SearchWordsError = SearchWordsErrors[keyof SearchWordsErrors];
+export type SearchWordsResponses = {
+    /**
+     * OK
+     */
+    200: SearchMultipleResponse;
+};
+export type SearchWordsResponse = SearchWordsResponses[keyof SearchWordsResponses];
+export type MediaIndexData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Number of results per page
+         */
+        limit?: number;
+        /**
+         * Pagination cursor offset
+         */
+        cursor?: number;
+        /**
+         * Filter by media category
+         */
+        category?: 'ANIME' | 'JDRAMA';
+        /**
+         * Search query for filtering media by name
+         */
+        query?: string;
+    };
+    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 = {
+    /**
+     * OK
+     */
+    200: {
+        message?: string;
+        id?: number;
+    };
+};
+export type MediaDestroyResponse = MediaDestroyResponses[keyof MediaDestroyResponses];
+export type MediaShowData = {
+    body?: never;
+    path: {
+        /**
+         * Media ID
+         */
+        id: number;
+    };
+    query?: never;
+    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
+         */
+        size?: 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
+         */
+        mediaId: number;
+        /**
+         * Episode number
+         */
+        episodeNumber: number;
+    };
+    query?: never;
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}';
+};
+export type EpisodeShowErrors = {
+    /**
+     * 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 EpisodeShowError = EpisodeShowErrors[keyof EpisodeShowErrors];
+export type EpisodeShowResponses = {
+    /**
+     * Single episode response
+     */
+    200: Episode;
+};
+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/{mediaId}/episodes/{episodeNumber}';
+};
+export type EpisodeUpdateErrors = {
+    /**
+     * 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 EpisodeUpdateError = EpisodeUpdateErrors[keyof EpisodeUpdateErrors];
+export type EpisodeUpdateResponses = {
+    /**
+     * Single episode response
+     */
+    200: Episode;
+};
+export type EpisodeUpdateResponse = EpisodeUpdateResponses[keyof EpisodeUpdateResponses];
+export type SegmentIndexData = {
+    body?: never;
+    path: {
+        /**
+         * ID of the media
+         */
+        mediaId: number;
+        /**
+         * Episode number
+         */
+        episodeNumber: number;
+    };
+    query?: {
+        /**
+         * Maximum number of segments to return
+         */
+        size?: number;
+        /**
+         * Segment ID to start from (for pagination)
+         */
+        cursor?: number;
+    };
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments';
+};
+export type SegmentIndexErrors = {
+    /**
+     * 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 SegmentIndexError = SegmentIndexErrors[keyof SegmentIndexErrors];
+export type SegmentIndexResponses = {
+    /**
+     * Paginated list of segments
+     */
+    200: SegmentListResponse;
+};
+export type SegmentIndexResponse = SegmentIndexResponses[keyof SegmentIndexResponses];
+export type SegmentCreateData = {
+    body: SegmentCreateRequest;
+    path: {
+        /**
+         * ID of the media
+         */
+        mediaId: number;
+        /**
+         * Episode number
+         */
+        episodeNumber: number;
+    };
+    query?: never;
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments';
+};
+export type SegmentCreateErrors = {
+    /**
+     * 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 SegmentCreateError = SegmentCreateErrors[keyof SegmentCreateErrors];
+export type SegmentCreateResponses = {
+    /**
+     * Single segment response
+     */
+    201: Segment;
+};
+export type SegmentCreateResponse = SegmentCreateResponses[keyof SegmentCreateResponses];
+export type SegmentDestroyData = {
+    body?: never;
+    path: {
+        /**
+         * ID of the media
+         */
+        mediaId: number;
+        /**
+         * Episode number
+         */
+        episodeNumber: number;
+        /**
+         * Segment ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments/{id}';
+};
+export type SegmentDestroyErrors = {
+    /**
+     * 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 SegmentDestroyError = SegmentDestroyErrors[keyof SegmentDestroyErrors];
+export type SegmentDestroyResponses = {
+    /**
+     * Segment successfully deleted
+     */
+    204: void;
+};
+export type SegmentDestroyResponse = SegmentDestroyResponses[keyof SegmentDestroyResponses];
+export type SegmentShowData = {
+    body?: never;
+    path: {
+        /**
+         * ID of the media
+         */
+        mediaId: number;
+        /**
+         * Episode number
+         */
+        episodeNumber: number;
+        /**
+         * Segment ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments/{id}';
+};
+export type SegmentShowErrors = {
+    /**
+     * 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 SegmentShowError = SegmentShowErrors[keyof SegmentShowErrors];
+export type SegmentShowResponses = {
+    /**
+     * Single segment response
+     */
+    200: Segment;
+};
+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/{episodeNumber}/segments/{id}';
+};
+export type SegmentUpdateErrors = {
+    /**
+     * 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 SegmentUpdateError = SegmentUpdateErrors[keyof SegmentUpdateErrors];
+export type SegmentUpdateResponses = {
+    /**
+     * Single segment response
+     */
+    200: Segment;
+};
+export type SegmentUpdateResponse = SegmentUpdateResponses[keyof SegmentUpdateResponses];
+export type SegmentShowByUuidData = {
+    body?: never;
+    path: {
+        /**
+         * Segment UUID
+         */
+        uuid: string;
+    };
+    query?: never;
+    url: '/v1/media/segments/{uuid}';
+};
+export type SegmentShowByUuidErrors = {
+    /**
+     * 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 SegmentShowByUuidError = SegmentShowByUuidErrors[keyof SegmentShowByUuidErrors];
+export type SegmentShowByUuidResponses = {
+    200: Segment;
+};
+export type SegmentShowByUuidResponse = SegmentShowByUuidResponses[keyof SegmentShowByUuidResponses];
+export type SegmentContextShowData = {
+    body?: never;
+    path: {
+        /**
+         * Segment UUID
+         */
+        uuid: string;
+    };
+    query?: {
+        /**
+         * Number of segments to return before and after the target
+         */
+        limit?: number;
+    };
+    url: '/v1/media/segments/{uuid}/context';
+};
+export type SegmentContextShowErrors = {
+    /**
+     * 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 SegmentContextShowError = SegmentContextShowErrors[keyof SegmentContextShowErrors];
+export type SegmentContextShowResponses = {
+    /**
+     * OK
+     */
+    200: SegmentContextResponse;
+};
+export type SegmentContextShowResponse = SegmentContextShowResponses[keyof SegmentContextShowResponses];
+export type CharacterShowData = {
+    body?: never;
+    path: {
+        /**
+         * AniList character ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/media/characters/{id}';
+};
+export type CharacterShowErrors = {
+    /**
+     * 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 CharacterShowError = CharacterShowErrors[keyof CharacterShowErrors];
+export type CharacterShowResponses = {
+    /**
+     * OK
+     */
+    200: CharacterWithMedia;
+};
+export type CharacterShowResponse = CharacterShowResponses[keyof CharacterShowResponses];
+export type SeiyuuShowData = {
+    body?: never;
+    path: {
+        /**
+         * AniList staff ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/media/seiyuu/{id}';
+};
+export type SeiyuuShowErrors = {
+    /**
+     * 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 SeiyuuShowError = SeiyuuShowErrors[keyof SeiyuuShowErrors];
+export type SeiyuuShowResponses = {
+    /**
+     * OK
+     */
+    200: SeiyuuWithRoles;
+};
+export type SeiyuuShowResponse = SeiyuuShowResponses[keyof SeiyuuShowResponses];
+export type UserQuotaShowData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/user/quota';
+};
+export type UserQuotaShowErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type UserQuotaShowError = UserQuotaShowErrors[keyof UserQuotaShowErrors];
+export type UserQuotaShowResponses = {
+    /**
+     * OK
+     */
+    200: UserQuotaResponse;
+};
+export type UserQuotaShowResponse = UserQuotaShowResponses[keyof UserQuotaShowResponses];
+export type UserReportIndexData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Cursor for pagination (report ID to start after)
+         */
+        cursor?: number;
+        /**
+         * Number of results per page
+         */
+        size?: number;
+        /**
+         * Filter by report status
+         */
+        status?: 'PENDING' | 'CONCERN' | 'ACCEPTED' | 'REJECTED' | 'RESOLVED' | 'IGNORED';
+    };
+    url: '/v1/user/reports';
+};
+export type UserReportIndexErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type UserReportIndexError = UserReportIndexErrors[keyof UserReportIndexErrors];
+export type UserReportIndexResponses = {
+    /**
+     * OK
+     */
+    200: ReportListResponse;
+};
+export type UserReportIndexResponse = UserReportIndexResponses[keyof UserReportIndexResponses];
+export type UserReportCreateData = {
+    body: CreateReportRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/user/reports';
+};
+export type UserReportCreateErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type UserReportCreateError = UserReportCreateErrors[keyof UserReportCreateErrors];
+export type UserReportCreateResponses = {
+    /**
+     * Report created successfully
+     */
+    201: Report;
+};
+export type UserReportCreateResponse = UserReportCreateResponses[keyof UserReportCreateResponses];
+export type UserPreferencesShowData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/user/preferences';
+};
+export type UserPreferencesShowErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type UserPreferencesShowError = UserPreferencesShowErrors[keyof UserPreferencesShowErrors];
+export type UserPreferencesShowResponses = {
+    /**
+     * OK
+     */
+    200: UserPreferences;
+};
+export type UserPreferencesShowResponse = UserPreferencesShowResponses[keyof UserPreferencesShowResponses];
+export type UserPreferencesUpdateData = {
+    body: UserPreferences;
+    path?: never;
+    query?: never;
+    url: '/v1/user/preferences';
+};
+export type UserPreferencesUpdateErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type UserPreferencesUpdateError = UserPreferencesUpdateErrors[keyof UserPreferencesUpdateErrors];
+export type UserPreferencesUpdateResponses = {
+    /**
+     * OK
+     */
+    200: UserPreferences;
+};
+export type UserPreferencesUpdateResponse = UserPreferencesUpdateResponses[keyof UserPreferencesUpdateResponses];
+export type UserActivityDestroyData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Only clear activities of this type
+         */
+        activityType?: ActivityType;
+    };
+    url: '/v1/user/activity';
+};
+export type UserActivityDestroyErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type UserActivityDestroyError = UserActivityDestroyErrors[keyof UserActivityDestroyErrors];
+export type UserActivityDestroyResponses = {
+    /**
+     * OK
+     */
+    200: {
+        message: string;
+        deletedCount: number;
+    };
+};
+export type UserActivityDestroyResponse = UserActivityDestroyResponses[keyof UserActivityDestroyResponses];
+export type UserActivityIndexData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Cursor for pagination (activity ID to start after)
+         */
+        cursor?: number;
+        /**
+         * Number of results per page
+         */
+        size?: number;
+        /**
+         * Filter by activity type
+         */
+        activityType?: ActivityType;
+    };
+    url: '/v1/user/activity';
+};
+export type UserActivityIndexErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type UserActivityIndexError = UserActivityIndexErrors[keyof UserActivityIndexErrors];
+export type UserActivityIndexResponses = {
+    /**
+     * OK
+     */
+    200: {
+        data: Array<UserActivity>;
+        hasMore: boolean;
+        cursor?: number;
+    };
+};
+export type UserActivityIndexResponse = UserActivityIndexResponses[keyof UserActivityIndexResponses];
+export type UserActivityStatsShowData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/user/activity/stats';
+};
+export type UserActivityStatsShowErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type UserActivityStatsShowError = UserActivityStatsShowErrors[keyof UserActivityStatsShowErrors];
+export type UserActivityStatsShowResponses = {
+    /**
+     * OK
+     */
+    200: {
+        totalSearches: number;
+        totalExports: number;
+        totalPlays: number;
+        totalListAdds: number;
+        /**
+         * Consecutive days with at least one activity
+         */
+        streakDays: number;
+        topMedia: Array<{
+            mediaId: number;
+            count: number;
+        }>;
+    };
+};
+export type UserActivityStatsShowResponse = UserActivityStatsShowResponses[keyof UserActivityStatsShowResponses];
+export type UserExportShowData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/user/export';
+};
+export type UserExportShowErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type UserExportShowError = UserExportShowErrors[keyof UserExportShowErrors];
+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;
+        }>;
+    };
+};
+export type UserExportShowResponse = UserExportShowResponses[keyof UserExportShowResponses];
+export type LabIndexData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/labs';
+};
+export type LabIndexErrors = {
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type LabIndexError = LabIndexErrors[keyof LabIndexErrors];
+export type LabIndexResponses = {
+    /**
+     * OK
+     */
+    200: Array<LabFeature>;
+};
+export type LabIndexResponse = LabIndexResponses[keyof LabIndexResponses];
+export type ListIndexData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Filter by visibility
+         */
+        visibility?: 'public' | 'private';
+        /**
+         * Filter by list type
+         */
+        type?: 'SERIES' | 'CUSTOM' | 'SEGMENT';
+        /**
+         * Filter by list owner user ID
+         */
+        userId?: number;
+        /**
+         * Filter lists containing this media ID
+         */
+        mediaId?: number;
+    };
+    url: '/v1/lists';
+};
+export type ListIndexErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type ListIndexError = ListIndexErrors[keyof ListIndexErrors];
+export type ListIndexResponses = {
+    /**
+     * OK
+     */
+    200: Array<List>;
+};
+export type ListIndexResponse = ListIndexResponses[keyof ListIndexResponses];
+export type ListCreateData = {
+    body: ListCreateRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/lists';
+};
+export type ListCreateErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type ListCreateError = ListCreateErrors[keyof ListCreateErrors];
+export type ListCreateResponses = {
+    /**
+     * Created
+     */
+    201: List;
+};
+export type ListCreateResponse = ListCreateResponses[keyof ListCreateResponses];
+export type ListDestroyData = {
+    body?: never;
+    path: {
+        /**
+         * List ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/lists/{id}';
+};
+export type ListDestroyErrors = {
+    /**
+     * 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 ListDestroyError = ListDestroyErrors[keyof ListDestroyErrors];
+export type ListDestroyResponses = {
+    /**
+     * OK
+     */
+    200: {
+        message?: string;
+        id?: number;
+    };
+};
+export type ListDestroyResponse = ListDestroyResponses[keyof ListDestroyResponses];
+export type ListShowData = {
+    body?: never;
+    path: {
+        /**
+         * List 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: {
+        /**
+         * List ID
+         */
+        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;
+        /**
+         * Position in the list (1-indexed)
+         */
+        position: number;
+    };
+    path: {
+        /**
+         * List ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/lists/{id}/items';
+};
+export type ListAddItemErrors = {
+    /**
+     * 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 ListAddItemError = ListAddItemErrors[keyof ListAddItemErrors];
+export type ListAddItemResponses = {
+    /**
+     * Created
+     */
+    201: {
+        message?: string;
+    };
+};
+export type ListAddItemResponse = ListAddItemResponses[keyof ListAddItemResponses];
+export type ListRemoveItemData = {
+    body?: never;
+    path: {
+        /**
+         * List ID
+         */
+        id: number;
+        /**
+         * Media ID
+         */
+        mediaId: number;
+    };
+    query?: never;
+    url: '/v1/lists/{id}/items/{mediaId}';
+};
+export type ListRemoveItemErrors = {
+    /**
+     * 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 ListRemoveItemError = ListRemoveItemErrors[keyof ListRemoveItemErrors];
+export type ListRemoveItemResponses = {
+    /**
+     * OK
+     */
+    200: {
+        message?: string;
+    };
+};
+export type ListRemoveItemResponse = ListRemoveItemResponses[keyof ListRemoveItemResponses];
+export type ListUpdateItemData = {
+    body: {
+        /**
+         * New position in the list (1-indexed)
+         */
+        position: number;
+    };
+    path: {
+        /**
+         * List ID
+         */
+        id: number;
+        /**
+         * Media ID
+         */
+        mediaId: number;
+    };
+    query?: never;
+    url: '/v1/lists/{id}/items/{mediaId}';
+};
+export type ListUpdateItemErrors = {
+    /**
+     * 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 ListUpdateItemError = ListUpdateItemErrors[keyof ListUpdateItemErrors];
+export type ListUpdateItemResponses = {
+    /**
+     * OK
+     */
+    200: {
+        message?: string;
+    };
+};
+export type ListUpdateItemResponse = ListUpdateItemResponses[keyof ListUpdateItemResponses];
+export type ListGetSegmentsData = {
+    body?: never;
+    path: {
+        /**
+         * List ID
+         */
+        id: number;
+    };
+    query?: {
+        /**
+         * Page number (1-indexed)
+         */
+        page?: number;
+        /**
+         * Items per page
+         */
+        limit?: number;
+    };
+    url: '/v1/lists/{id}/segments';
+};
+export type ListGetSegmentsErrors = {
+    /**
+     * 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 ListGetSegmentsError = ListGetSegmentsErrors[keyof ListGetSegmentsErrors];
+export type ListGetSegmentsResponses = {
+    /**
+     * OK
+     */
+    200: ListWithSegments;
+};
+export type ListGetSegmentsResponse = ListGetSegmentsResponses[keyof ListGetSegmentsResponses];
+export type ListAddSegmentData = {
+    body: {
+        /**
+         * UUID of the segment to add
+         */
+        segmentUuid: string;
+        /**
+         * Optional annotation
+         */
+        note?: string;
+    };
+    path: {
+        /**
+         * List ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/lists/{id}/segments';
+};
+export type ListAddSegmentErrors = {
+    /**
+     * 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 ListAddSegmentError = ListAddSegmentErrors[keyof ListAddSegmentErrors];
+export type ListAddSegmentResponses = {
+    /**
+     * Created
+     */
+    201: {
+        message?: string;
+    };
+};
+export type ListAddSegmentResponse = ListAddSegmentResponses[keyof ListAddSegmentResponses];
+export type ListRemoveSegmentData = {
+    body?: never;
+    path: {
+        /**
+         * List ID
+         */
+        id: number;
+        /**
+         * Segment UUID
+         */
+        uuid: string;
+    };
+    query?: never;
+    url: '/v1/lists/{id}/segments/{uuid}';
+};
+export type ListRemoveSegmentErrors = {
+    /**
+     * 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 ListRemoveSegmentError = ListRemoveSegmentErrors[keyof ListRemoveSegmentErrors];
+export type ListRemoveSegmentResponses = {
+    /**
+     * OK
+     */
+    200: {
+        message?: string;
+    };
+};
+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;
+    };
+    query?: never;
+    url: '/v1/lists/{id}/segments/{uuid}';
+};
+export type ListUpdateSegmentErrors = {
+    /**
+     * 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 ListUpdateSegmentError = ListUpdateSegmentErrors[keyof ListUpdateSegmentErrors];
+export type ListUpdateSegmentResponses = {
+    /**
+     * OK
+     */
+    200: {
+        message?: string;
+    };
+};
+export type ListUpdateSegmentResponse = ListUpdateSegmentResponses[keyof ListUpdateSegmentResponses];
+export type AdminReindexCreateData = {
+    body?: ReindexRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/admin/reindex';
+};
+export type AdminReindexCreateErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminReindexCreateError = AdminReindexCreateErrors[keyof AdminReindexCreateErrors];
+export type AdminReindexCreateResponses = {
+    /**
+     * Reindex operation completed
+     */
+    200: ReindexResponse;
+};
+export type AdminReindexCreateResponse = AdminReindexCreateResponses[keyof AdminReindexCreateResponses];
+export type AdminQueueStatsIndexData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/admin/queues/stats';
+};
+export type AdminQueueStatsIndexErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminQueueStatsIndexError = AdminQueueStatsIndexErrors[keyof AdminQueueStatsIndexErrors];
+export type AdminQueueStatsIndexResponses = {
+    /**
+     * Queue statistics retrieved successfully
+     */
+    200: Array<{
+        queue?: string;
+        /**
+         * Number of jobs currently pending/active
+         */
+        stuckCount?: number;
+        /**
+         * Number of failed jobs
+         */
+        failedCount?: number;
+    }>;
+};
+export type AdminQueueStatsIndexResponse = AdminQueueStatsIndexResponses[keyof AdminQueueStatsIndexResponses];
+export type AdminQueueShowData = {
+    body?: never;
+    path: {
+        /**
+         * The name of the queue
+         */
+        queueName: 'es-sync-create' | 'es-sync-update' | 'es-sync-delete';
+    };
+    query?: never;
+    url: '/v1/admin/queues/{queueName}';
+};
+export type AdminQueueShowErrors = {
+    /**
+     * 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 AdminQueueShowError = AdminQueueShowErrors[keyof AdminQueueShowErrors];
+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;
+    };
+};
+export type AdminQueueShowResponse = AdminQueueShowResponses[keyof AdminQueueShowResponses];
+export type AdminQueueFailedIndexData = {
+    body?: never;
+    path: {
+        /**
+         * The name of the queue
+         */
+        queueName: 'es-sync-create' | 'es-sync-update' | 'es-sync-delete';
+    };
+    query?: never;
+    url: '/v1/admin/queues/{queueName}/failed';
+};
+export type AdminQueueFailedIndexErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminQueueFailedIndexError = AdminQueueFailedIndexErrors[keyof AdminQueueFailedIndexErrors];
+export type AdminQueueFailedIndexResponses = {
+    /**
+     * Failed jobs retrieved successfully
+     */
+    200: Array<{
+        /**
+         * Job ID
+         */
+        id?: string;
+        /**
+         * The segment ID that failed to sync
+         */
+        segmentId?: number;
+        /**
+         * Error message from the last attempt
+         */
+        error?: string;
+        /**
+         * When the job was created
+         */
+        createdOn?: string;
+    }>;
+};
+export type AdminQueueFailedIndexResponse = AdminQueueFailedIndexResponses[keyof AdminQueueFailedIndexResponses];
+export type AdminQueueRetryCreateData = {
+    body?: never;
+    path: {
+        /**
+         * The name of the queue
+         */
+        queueName: 'es-sync-create' | 'es-sync-update' | 'es-sync-delete';
+    };
+    query?: never;
+    url: '/v1/admin/queues/{queueName}/retry';
+};
+export type AdminQueueRetryCreateErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminQueueRetryCreateError = AdminQueueRetryCreateErrors[keyof AdminQueueRetryCreateErrors];
+export type AdminQueueRetryCreateResponses = {
+    /**
+     * Jobs queued for retry
+     */
+    200: {
+        success?: boolean;
+        /**
+         * Number of jobs queued for retry
+         */
+        retriedCount?: number;
+        message?: string;
+    };
+};
+export type AdminQueueRetryCreateResponse = AdminQueueRetryCreateResponses[keyof AdminQueueRetryCreateResponses];
+export type AdminQueueFailedDestroyData = {
+    body?: never;
+    path: {
+        /**
+         * The name of the queue
+         */
+        queueName: 'es-sync-create' | 'es-sync-update' | 'es-sync-delete';
+    };
+    query?: never;
+    url: '/v1/admin/queues/{queueName}/purge';
+};
+export type AdminQueueFailedDestroyErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminQueueFailedDestroyError = AdminQueueFailedDestroyErrors[keyof AdminQueueFailedDestroyErrors];
+export type AdminQueueFailedDestroyResponses = {
+    /**
+     * Failed jobs purged successfully
+     */
+    200: {
+        success?: boolean;
+        /**
+         * Number of failed jobs deleted
+         */
+        purgedCount?: number;
+        message?: string;
+    };
+};
+export type AdminQueueFailedDestroyResponse = AdminQueueFailedDestroyResponses[keyof AdminQueueFailedDestroyResponses];
+export type AdminMorphemeBackfillCreateData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/admin/morpheme-backfill';
+};
+export type AdminMorphemeBackfillCreateResponses = {
+    /**
+     * Backfill completed
+     */
+    200: {
+        success: boolean;
+        message: string;
+        stats: {
+            totalSegments: number;
+            successfulAnalyses: number;
+            failedAnalyses: number;
+        };
+    };
+};
+export type AdminMorphemeBackfillCreateResponse = AdminMorphemeBackfillCreateResponses[keyof AdminMorphemeBackfillCreateResponses];
+export type AdminReportIndexData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Cursor for pagination (report ID to start after)
+         */
+        cursor?: number;
+        /**
+         * Number of results per page
+         */
+        size?: number;
+        /**
+         * Filter by report status
+         */
+        status?: 'PENDING' | 'CONCERN' | 'ACCEPTED' | 'REJECTED' | 'RESOLVED' | 'IGNORED';
+        /**
+         * Filter by report source
+         */
+        source?: 'USER' | 'AUTO';
+        /**
+         * Filter by target type
+         */
+        targetType?: 'SEGMENT' | 'EPISODE' | 'MEDIA';
+        /**
+         * Filter by target media ID
+         */
+        targetMediaId?: number;
+        /**
+         * Filter by review check run ID
+         */
+        reviewCheckRunId?: number;
+    };
+    url: '/v1/admin/reports';
+};
+export type AdminReportIndexErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminReportIndexError = AdminReportIndexErrors[keyof AdminReportIndexErrors];
+export type AdminReportIndexResponses = {
+    /**
+     * OK
+     */
+    200: AdminReportListResponse;
+};
+export type AdminReportIndexResponse = AdminReportIndexResponses[keyof AdminReportIndexResponses];
+export type AdminReportUpdateData = {
+    body: UpdateReportRequest;
+    path: {
+        /**
+         * Report ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/admin/reports/{id}';
+};
+export type AdminReportUpdateErrors = {
+    /**
+     * 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 AdminReportUpdateError = AdminReportUpdateErrors[keyof AdminReportUpdateErrors];
+export type AdminReportUpdateResponses = {
+    /**
+     * Report updated successfully
+     */
+    200: Report;
+};
+export type AdminReportUpdateResponse = AdminReportUpdateResponses[keyof AdminReportUpdateResponses];
+export type AdminReviewRunCreateData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Optional category filter
+         */
+        category?: 'ANIME' | 'JDRAMA';
+    };
+    url: '/v1/admin/review/run';
+};
+export type AdminReviewRunCreateErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminReviewRunCreateError = AdminReviewRunCreateErrors[keyof AdminReviewRunCreateErrors];
+export type AdminReviewRunCreateResponses = {
+    /**
+     * Check run completed
+     */
+    200: RunReviewResponse;
+};
+export type AdminReviewRunCreateResponse = AdminReviewRunCreateResponses[keyof AdminReviewRunCreateResponses];
+export type AdminReviewCheckIndexData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/admin/review/checks';
+};
+export type AdminReviewCheckIndexErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminReviewCheckIndexError = AdminReviewCheckIndexErrors[keyof AdminReviewCheckIndexErrors];
+export type AdminReviewCheckIndexResponses = {
+    /**
+     * OK
+     */
+    200: Array<ReviewCheck>;
+};
+export type AdminReviewCheckIndexResponse = AdminReviewCheckIndexResponses[keyof AdminReviewCheckIndexResponses];
+export type AdminReviewCheckUpdateData = {
+    body: {
+        /**
+         * New threshold values
+         */
+        threshold?: {
+            [key: string]: unknown;
+        };
+        /**
+         * Enable or disable this check
+         */
+        enabled?: boolean;
+    };
+    path: {
+        /**
+         * Check name identifier
+         */
+        name: string;
+    };
+    query?: never;
+    url: '/v1/admin/review/checks/{name}';
+};
+export type AdminReviewCheckUpdateErrors = {
+    /**
+     * 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 AdminReviewCheckUpdateError = AdminReviewCheckUpdateErrors[keyof AdminReviewCheckUpdateErrors];
+export type AdminReviewCheckUpdateResponses = {
+    /**
+     * Check updated successfully
+     */
+    200: ReviewCheck;
+};
+export type AdminReviewCheckUpdateResponse = AdminReviewCheckUpdateResponses[keyof AdminReviewCheckUpdateResponses];
+export type AdminReviewRunIndexData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Filter by check name
+         */
+        checkName?: string;
+        /**
+         * Cursor for pagination
+         */
+        cursor?: number;
+        /**
+         * Number of results per page
+         */
+        size?: number;
+    };
+    url: '/v1/admin/review/runs';
+};
+export type AdminReviewRunIndexErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminReviewRunIndexError = AdminReviewRunIndexErrors[keyof AdminReviewRunIndexErrors];
+export type AdminReviewRunIndexResponses = {
+    /**
+     * OK
+     */
+    200: {
+        data: Array<ReviewCheckRun>;
+        hasMore: boolean;
+        cursor?: number;
+    };
+};
+export type AdminReviewRunIndexResponse = AdminReviewRunIndexResponses[keyof AdminReviewRunIndexResponses];
+export type AdminReviewRunShowData = {
+    body?: never;
+    path: {
+        /**
+         * Run ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/admin/review/runs/{id}';
+};
+export type AdminReviewRunShowErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminReviewRunShowError = AdminReviewRunShowErrors[keyof AdminReviewRunShowErrors];
+export type AdminReviewRunShowResponses = {
+    /**
+     * OK
+     */
+    200: {
+        run: ReviewCheckRun;
+        reports: Array<Report>;
+    };
+};
+export type AdminReviewRunShowResponse = AdminReviewRunShowResponses[keyof AdminReviewRunShowResponses];
+export type AdminReviewAllowlistIndexData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Filter by check name
+         */
+        checkName?: string;
+    };
+    url: '/v1/admin/review/allowlist';
+};
+export type AdminReviewAllowlistIndexErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminReviewAllowlistIndexError = AdminReviewAllowlistIndexErrors[keyof AdminReviewAllowlistIndexErrors];
+export type AdminReviewAllowlistIndexResponses = {
+    /**
+     * OK
+     */
+    200: Array<ReviewAllowlist>;
+};
+export type AdminReviewAllowlistIndexResponse = AdminReviewAllowlistIndexResponses[keyof AdminReviewAllowlistIndexResponses];
+export type AdminReviewAllowlistCreateData = {
+    body: {
+        /**
+         * Check name to allowlist for
+         */
+        checkName: string;
+        /**
+         * Media ID to allowlist
+         */
+        mediaId: number;
+        /**
+         * Episode number (for episode-level checks)
+         */
+        episodeNumber?: number;
+        /**
+         * Reason for allowlisting
+         */
+        reason?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/v1/admin/review/allowlist';
+};
+export type AdminReviewAllowlistCreateErrors = {
+    /**
+     * 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 AdminReviewAllowlistCreateError = AdminReviewAllowlistCreateErrors[keyof AdminReviewAllowlistCreateErrors];
+export type AdminReviewAllowlistCreateResponses = {
+    /**
+     * Added to allowlist
+     */
+    201: ReviewAllowlist;
+};
+export type AdminReviewAllowlistCreateResponse = AdminReviewAllowlistCreateResponses[keyof AdminReviewAllowlistCreateResponses];
+export type AdminReviewAllowlistDestroyData = {
+    body?: never;
+    path: {
+        /**
+         * Allowlist entry ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/admin/review/allowlist/{id}';
+};
+export type AdminReviewAllowlistDestroyErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminReviewAllowlistDestroyError = AdminReviewAllowlistDestroyErrors[keyof AdminReviewAllowlistDestroyErrors];
+export type AdminReviewAllowlistDestroyResponses = {
+    /**
+     * Removed from allowlist
+     */
+    204: void;
+};
+export type AdminReviewAllowlistDestroyResponse = AdminReviewAllowlistDestroyResponses[keyof AdminReviewAllowlistDestroyResponses];
+//# sourceMappingURL=types.gen.d.ts.map