@brigadasos/nadeshiko-sdk 2.0.7 → 2.1.0-internal

package/dist/nadeshiko.gen.d.ts

@@ -1,25 +1,32 @@
 import { type Client } from './client';
 import type * as Types from './types.gen';
-import { type Options } from './sdk.gen';
 import { type RetryOptions } from './retry';
 type ApiKeyProvider = string | (() => string | undefined | Promise<string | undefined>);
 export interface NadeshikoConfig {
     /**
      * API key for Bearer token authentication.
-     * Public SDK only supports API key authentication.
+     * Used for API key protected endpoints.
      */
     apiKey?: ApiKeyProvider;
+    /**
+     * A function that returns the session token for cookie-based authentication.
+     * Used for session-protected endpoints (e.g. /v1/user/* and /v1/collections/*).
+     * Defaults to reading the `nadeshiko.session_token` cookie from `document.cookie`.
+     */
+    sessionToken?: () => string | undefined | Promise<string | undefined>;
     /** Base URL of the Nadeshiko API. Accepts `'LOCAL'`, `'DEVELOPMENT'`, `'PRODUCTION'`, or a custom URL string. */
     baseURL?: 'LOCAL' | 'DEVELOPMENT' | 'PRODUCTION' | string;
     /** @deprecated Use `baseURL` instead */
     baseUrl?: 'LOCAL' | 'DEVELOPMENT' | 'PRODUCTION' | string;
     /** Retry configuration for failed requests. Retries on network errors and 408/429/5xx responses. */
     retryOptions?: RetryOptions;
+    /** Default headers sent with every request (e.g. User-Agent, tracing headers). */
+    headers?: Record<string, string>;
 }
 export type NadeshikoClient = {
     client: Client;
     search: {
-        (options: Options<Types.SearchData, boolean> & {
+        (params: NonNullable<Types.SearchData['body']> & {
             throwOnError: false;
         }): Promise<{
             data: Types.SearchResponse;
@@ -30,14 +37,11 @@ export type NadeshikoClient = {
             response: Response;
             request: Request;
         }>;
-        (options?: Options<Types.SearchData, boolean>): Promise<{
-            data: Types.SearchResponse;
-            response: Response;
-            request: Request;
-        }>;
+        (params?: NonNullable<Types.SearchData['body']>): Promise<Types.SearchResponse>;
+        paginate: (params?: NonNullable<Types.SearchData['body']>) => AsyncGenerator<Types.SearchResponse['segments'][number], void, unknown>;
     };
     getSearchStats: {
-        (options: Options<Types.GetSearchStatsData, boolean> & {
+        (params: NonNullable<Types.GetSearchStatsData['body']> & {
             throwOnError: false;
         }): Promise<{
             data: Types.GetSearchStatsResponse;
@@ -48,14 +52,10 @@ export type NadeshikoClient = {
             response: Response;
             request: Request;
         }>;
-        (options?: Options<Types.GetSearchStatsData, boolean>): Promise<{
-            data: Types.GetSearchStatsResponse;
-            response: Response;
-            request: Request;
-        }>;
+        (params?: NonNullable<Types.GetSearchStatsData['body']>): Promise<Types.GetSearchStatsResponse>;
     };
     searchWords: {
-        (options: Options<Types.SearchWordsData, boolean> & {
+        (params: NonNullable<Types.SearchWordsData['body']> & {
             throwOnError: false;
         }): Promise<{
             data: Types.SearchWordsResponse;
@@ -66,14 +66,24 @@ export type NadeshikoClient = {
             response: Response;
             request: Request;
         }>;
-        (options?: Options<Types.SearchWordsData, boolean>): Promise<{
-            data: Types.SearchWordsResponse;
+        (params: NonNullable<Types.SearchWordsData['body']>): Promise<Types.SearchWordsResponse>;
+    };
+    searchMedia: {
+        (params: NonNullable<Types.SearchMediaData['body']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.SearchMediaResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.SearchMediaErrors;
             response: Response;
             request: Request;
         }>;
+        (params: NonNullable<Types.SearchMediaData['body']>): Promise<Types.SearchMediaResponse>;
     };
     getStatsOverview: {
-        (options: Options<Types.GetStatsOverviewData, boolean> & {
+        (params: {
             throwOnError: false;
         }): Promise<{
             data: Types.GetStatsOverviewResponse;
@@ -84,14 +94,303 @@ export type NadeshikoClient = {
             response: Response;
             request: Request;
         }>;
-        (options?: Options<Types.GetStatsOverviewData, boolean>): Promise<{
-            data: Types.GetStatsOverviewResponse;
+        (): Promise<Types.GetStatsOverviewResponse>;
+    };
+    listMedia: {
+        (params: NonNullable<Types.ListMediaData['query']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.ListMediaResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.ListMediaErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params?: NonNullable<Types.ListMediaData['query']>): Promise<Types.ListMediaResponse>;
+        paginate: (params?: NonNullable<Types.ListMediaData['query']>) => AsyncGenerator<Types.ListMediaResponse['media'][number], void, unknown>;
+    };
+    getSegment: {
+        (id: string): Promise<Types.GetSegmentResponse>;
+        (params: Types.GetSegmentData['path'] & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.GetSegmentResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.GetSegmentErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params: Types.GetSegmentData['path']): Promise<Types.GetSegmentResponse>;
+    };
+    getSegmentContext: {
+        (id: string): Promise<Types.GetSegmentContextResponse>;
+        (params: Types.GetSegmentContextData['path'] & NonNullable<Types.GetSegmentContextData['query']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.GetSegmentContextResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.GetSegmentContextErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params: Types.GetSegmentContextData['path'] & NonNullable<Types.GetSegmentContextData['query']>): Promise<Types.GetSegmentContextResponse>;
+    };
+    getMedia: {
+        (id: string): Promise<Types.GetMediaResponse>;
+        (params: Types.GetMediaData['path'] & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.GetMediaResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.GetMediaErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params: Types.GetMediaData['path']): Promise<Types.GetMediaResponse>;
+    };
+    listEpisodes: {
+        (id: string): Promise<Types.ListEpisodesResponse>;
+        (params: Types.ListEpisodesData['path'] & NonNullable<Types.ListEpisodesData['query']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.ListEpisodesResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.ListEpisodesErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params: Types.ListEpisodesData['path'] & NonNullable<Types.ListEpisodesData['query']>): Promise<Types.ListEpisodesResponse>;
+        paginate: (params?: Types.ListEpisodesData['path'] & NonNullable<Types.ListEpisodesData['query']>) => AsyncGenerator<Types.ListEpisodesResponse['episodes'][number], void, unknown>;
+    };
+    getEpisode: {
+        (params: Types.GetEpisodeData['path'] & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.GetEpisodeResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.GetEpisodeErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params: Types.GetEpisodeData['path']): Promise<Types.GetEpisodeResponse>;
+    };
+    getMe: {
+        (params: {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.GetMeResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.GetMeErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (): Promise<Types.GetMeResponse>;
+    };
+    listExcludedMedia: {
+        (params: {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.ListExcludedMediaResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.ListExcludedMediaErrors;
             response: Response;
             request: Request;
         }>;
+        (): Promise<Types.ListExcludedMediaResponse>;
+    };
+    addExcludedMedia: {
+        (params: NonNullable<Types.AddExcludedMediaData['body']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.AddExcludedMediaResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.AddExcludedMediaErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params: NonNullable<Types.AddExcludedMediaData['body']>): Promise<Types.AddExcludedMediaResponse>;
+    };
+    removeExcludedMedia: {
+        (id: string): Promise<Types.RemoveExcludedMediaResponse>;
+        (params: Types.RemoveExcludedMediaData['path'] & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.RemoveExcludedMediaResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.RemoveExcludedMediaErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params: Types.RemoveExcludedMediaData['path']): Promise<Types.RemoveExcludedMediaResponse>;
+    };
+    listUserActivity: {
+        (params: NonNullable<Types.ListUserActivityData['query']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.ListUserActivityResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.ListUserActivityErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params?: NonNullable<Types.ListUserActivityData['query']>): Promise<Types.ListUserActivityResponse>;
+        paginate: (params?: NonNullable<Types.ListUserActivityData['query']>) => AsyncGenerator<Types.ListUserActivityResponse['activities'][number], void, unknown>;
+    };
+    getUserActivityHeatmap: {
+        (params: NonNullable<Types.GetUserActivityHeatmapData['query']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.GetUserActivityHeatmapResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.GetUserActivityHeatmapErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params?: NonNullable<Types.GetUserActivityHeatmapData['query']>): Promise<Types.GetUserActivityHeatmapResponse>;
+    };
+    getUserActivityStats: {
+        (params: NonNullable<Types.GetUserActivityStatsData['query']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.GetUserActivityStatsResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.GetUserActivityStatsErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params?: NonNullable<Types.GetUserActivityStatsData['query']>): Promise<Types.GetUserActivityStatsResponse>;
+    };
+    listCollections: {
+        (params: NonNullable<Types.ListCollectionsData['query']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.ListCollectionsResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.ListCollectionsErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params?: NonNullable<Types.ListCollectionsData['query']>): Promise<Types.ListCollectionsResponse>;
+        paginate: (params?: NonNullable<Types.ListCollectionsData['query']>) => AsyncGenerator<Types.ListCollectionsResponse['collections'][number], void, unknown>;
+    };
+    createCollection: {
+        (params: NonNullable<Types.CreateCollectionData['body']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.CreateCollectionResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.CreateCollectionErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params: NonNullable<Types.CreateCollectionData['body']>): Promise<Types.CreateCollectionResponse>;
+    };
+    getCollection: {
+        (id: string): Promise<Types.GetCollectionResponse>;
+        (params: Types.GetCollectionData['path'] & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.GetCollectionResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.GetCollectionErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params: Types.GetCollectionData['path']): Promise<Types.GetCollectionResponse>;
+    };
+    deleteCollection: {
+        (id: string): Promise<Types.DeleteCollectionResponse>;
+        (params: Types.DeleteCollectionData['path'] & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.DeleteCollectionResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.DeleteCollectionErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params: Types.DeleteCollectionData['path']): Promise<Types.DeleteCollectionResponse>;
+    };
+    addSegmentToCollection: {
+        (params: Types.AddSegmentToCollectionData['path'] & NonNullable<Types.AddSegmentToCollectionData['body']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.AddSegmentToCollectionResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.AddSegmentToCollectionErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params: Types.AddSegmentToCollectionData['path'] & NonNullable<Types.AddSegmentToCollectionData['body']>): Promise<Types.AddSegmentToCollectionResponse>;
+    };
+    searchCollectionSegments: {
+        (id: string): Promise<Types.SearchCollectionSegmentsResponse>;
+        (params: Types.SearchCollectionSegmentsData['path'] & NonNullable<Types.SearchCollectionSegmentsData['body']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.SearchCollectionSegmentsResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.SearchCollectionSegmentsErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params: Types.SearchCollectionSegmentsData['path'] & NonNullable<Types.SearchCollectionSegmentsData['body']>): Promise<Types.SearchCollectionSegmentsResponse>;
+        paginate: (params?: Types.SearchCollectionSegmentsData['path'] & NonNullable<Types.SearchCollectionSegmentsData['body']>) => AsyncGenerator<Types.SearchCollectionSegmentsResponse['segments'][number], void, unknown>;
+    };
+    removeSegmentFromCollection: {
+        (params: Types.RemoveSegmentFromCollectionData['path'] & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.RemoveSegmentFromCollectionResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.RemoveSegmentFromCollectionErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params: Types.RemoveSegmentFromCollectionData['path']): Promise<Types.RemoveSegmentFromCollectionResponse>;
     };
     getCoveredWords: {
-        (options: Options<Types.GetCoveredWordsData, boolean> & {
+        (params: NonNullable<Types.GetCoveredWordsData['query']> & {
             throwOnError: false;
         }): Promise<{
             data: Types.GetCoveredWordsResponse;
@@ -102,173 +401,572 @@ export type NadeshikoClient = {
             response: Response;
             request: Request;
         }>;
-        (options?: Options<Types.GetCoveredWordsData, boolean>): Promise<{
-            data: Types.GetCoveredWordsResponse;
+        (params?: NonNullable<Types.GetCoveredWordsData['query']>): Promise<Types.GetCoveredWordsResponse>;
+        paginate: (params?: NonNullable<Types.GetCoveredWordsData['query']>) => AsyncGenerator<Types.GetCoveredWordsResponse['words'][number], void, unknown>;
+    };
+    triggerCoveredWordsUpdate: {
+        (params: NonNullable<Types.TriggerCoveredWordsUpdateData['body']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.TriggerCoveredWordsUpdateResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.TriggerCoveredWordsUpdateErrors;
             response: Response;
             request: Request;
         }>;
+        (params?: NonNullable<Types.TriggerCoveredWordsUpdateData['body']>): Promise<Types.TriggerCoveredWordsUpdateResponse>;
     };
-    listMedia: {
-        (options: Options<Types.ListMediaData, boolean> & {
+    createMedia: {
+        (params: NonNullable<Types.CreateMediaData['body']> & {
             throwOnError: false;
         }): Promise<{
-            data: Types.ListMediaResponse;
+            data: Types.CreateMediaResponse;
             response: Response;
             request: Request;
         } | {
-            error: Types.ListMediaErrors;
+            error: Types.CreateMediaErrors;
             response: Response;
             request: Request;
         }>;
-        (options?: Options<Types.ListMediaData, boolean>): Promise<{
-            data: Types.ListMediaResponse;
+        (params: NonNullable<Types.CreateMediaData['body']>): Promise<Types.CreateMediaResponse>;
+    };
+    updateSegment: {
+        (id: string): Promise<Types.UpdateSegmentResponse>;
+        (params: Types.UpdateSegmentData['path'] & NonNullable<Types.UpdateSegmentData['body']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.UpdateSegmentResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.UpdateSegmentErrors;
             response: Response;
             request: Request;
         }>;
+        (params: Types.UpdateSegmentData['path'] & NonNullable<Types.UpdateSegmentData['body']>): Promise<Types.UpdateSegmentResponse>;
     };
-    getSegmentByUuid: {
-        (options: Options<Types.GetSegmentByUuidData, boolean> & {
+    listSegmentRevisions: {
+        (id: string): Promise<Types.ListSegmentRevisionsResponse>;
+        (params: Types.ListSegmentRevisionsData['path'] & {
             throwOnError: false;
         }): Promise<{
-            data: Types.GetSegmentByUuidResponse;
+            data: Types.ListSegmentRevisionsResponse;
             response: Response;
             request: Request;
         } | {
-            error: Types.GetSegmentByUuidErrors;
+            error: Types.ListSegmentRevisionsErrors;
             response: Response;
             request: Request;
         }>;
-        (options?: Options<Types.GetSegmentByUuidData, boolean>): Promise<{
-            data: Types.GetSegmentByUuidResponse;
+        (params: Types.ListSegmentRevisionsData['path']): Promise<Types.ListSegmentRevisionsResponse>;
+    };
+    updateMedia: {
+        (id: string): Promise<Types.UpdateMediaResponse>;
+        (params: Types.UpdateMediaData['path'] & NonNullable<Types.UpdateMediaData['body']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.UpdateMediaResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.UpdateMediaErrors;
             response: Response;
             request: Request;
         }>;
+        (params: Types.UpdateMediaData['path'] & NonNullable<Types.UpdateMediaData['body']>): Promise<Types.UpdateMediaResponse>;
     };
-    getSegmentContext: {
-        (options: Options<Types.GetSegmentContextData, boolean> & {
+    deleteMedia: {
+        (id: string): Promise<Types.DeleteMediaResponse>;
+        (params: Types.DeleteMediaData['path'] & {
             throwOnError: false;
         }): Promise<{
-            data: Types.GetSegmentContextResponse;
+            data: Types.DeleteMediaResponse;
             response: Response;
             request: Request;
         } | {
-            error: Types.GetSegmentContextErrors;
+            error: Types.DeleteMediaErrors;
             response: Response;
             request: Request;
         }>;
-        (options?: Options<Types.GetSegmentContextData, boolean>): Promise<{
-            data: Types.GetSegmentContextResponse;
+        (params: Types.DeleteMediaData['path']): Promise<Types.DeleteMediaResponse>;
+    };
+    createEpisode: {
+        (params: Types.CreateEpisodeData['path'] & NonNullable<Types.CreateEpisodeData['body']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.CreateEpisodeResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.CreateEpisodeErrors;
             response: Response;
             request: Request;
         }>;
+        (params: Types.CreateEpisodeData['path'] & NonNullable<Types.CreateEpisodeData['body']>): Promise<Types.CreateEpisodeResponse>;
     };
-    listSeries: {
-        (options: Options<Types.ListSeriesData, boolean> & {
+    updateEpisode: {
+        (params: Types.UpdateEpisodeData['path'] & NonNullable<Types.UpdateEpisodeData['body']> & {
             throwOnError: false;
         }): Promise<{
-            data: Types.ListSeriesResponse;
+            data: Types.UpdateEpisodeResponse;
             response: Response;
             request: Request;
         } | {
-            error: Types.ListSeriesErrors;
+            error: Types.UpdateEpisodeErrors;
             response: Response;
             request: Request;
         }>;
-        (options?: Options<Types.ListSeriesData, boolean>): Promise<{
-            data: Types.ListSeriesResponse;
+        (params: Types.UpdateEpisodeData['path'] & NonNullable<Types.UpdateEpisodeData['body']>): Promise<Types.UpdateEpisodeResponse>;
+    };
+    deleteEpisode: {
+        (params: Types.DeleteEpisodeData['path'] & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.DeleteEpisodeResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.DeleteEpisodeErrors;
             response: Response;
             request: Request;
         }>;
+        (params: Types.DeleteEpisodeData['path']): Promise<Types.DeleteEpisodeResponse>;
     };
-    getSeries: {
-        (options: Options<Types.GetSeriesData, boolean> & {
+    listSegments: {
+        (params: Types.ListSegmentsData['path'] & NonNullable<Types.ListSegmentsData['query']> & {
             throwOnError: false;
         }): Promise<{
-            data: Types.GetSeriesResponse;
+            data: Types.ListSegmentsResponse;
             response: Response;
             request: Request;
         } | {
-            error: Types.GetSeriesErrors;
+            error: Types.ListSegmentsErrors;
             response: Response;
             request: Request;
         }>;
-        (options?: Options<Types.GetSeriesData, boolean>): Promise<{
-            data: Types.GetSeriesResponse;
+        (params: Types.ListSegmentsData['path'] & NonNullable<Types.ListSegmentsData['query']>): Promise<Types.ListSegmentsResponse>;
+        paginate: (params?: Types.ListSegmentsData['path'] & NonNullable<Types.ListSegmentsData['query']>) => AsyncGenerator<Types.ListSegmentsResponse['segments'][number], void, unknown>;
+    };
+    createSegment: {
+        (params: Types.CreateSegmentData['path'] & NonNullable<Types.CreateSegmentData['body']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.CreateSegmentResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.CreateSegmentErrors;
             response: Response;
             request: Request;
         }>;
+        (params: Types.CreateSegmentData['path'] & NonNullable<Types.CreateSegmentData['body']>): Promise<Types.CreateSegmentResponse>;
     };
-    getMedia: {
-        (options: Options<Types.GetMediaData, boolean> & {
+    createSegmentsBatch: {
+        (params: Types.CreateSegmentsBatchData['path'] & NonNullable<Types.CreateSegmentsBatchData['body']> & {
             throwOnError: false;
         }): Promise<{
-            data: Types.GetMediaResponse;
+            data: Types.CreateSegmentsBatchResponse;
             response: Response;
             request: Request;
         } | {
-            error: Types.GetMediaErrors;
+            error: Types.CreateSegmentsBatchErrors;
             response: Response;
             request: Request;
         }>;
-        (options?: Options<Types.GetMediaData, boolean>): Promise<{
-            data: Types.GetMediaResponse;
+        (params: Types.CreateSegmentsBatchData['path'] & NonNullable<Types.CreateSegmentsBatchData['body']>): Promise<Types.CreateSegmentsBatchResponse>;
+    };
+    createUserReport: {
+        (params: NonNullable<Types.CreateUserReportData['body']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.CreateUserReportResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.CreateUserReportErrors;
             response: Response;
             request: Request;
         }>;
+        (params: NonNullable<Types.CreateUserReportData['body']>): Promise<Types.CreateUserReportResponse>;
     };
-    listEpisodes: {
-        (options: Options<Types.ListEpisodesData, boolean> & {
+    getUserPreferences: {
+        (params: {
             throwOnError: false;
         }): Promise<{
-            data: Types.ListEpisodesResponse;
+            data: Types.GetUserPreferencesResponse;
             response: Response;
             request: Request;
         } | {
-            error: Types.ListEpisodesErrors;
+            error: Types.GetUserPreferencesErrors;
             response: Response;
             request: Request;
         }>;
-        (options?: Options<Types.ListEpisodesData, boolean>): Promise<{
-            data: Types.ListEpisodesResponse;
+        (): Promise<Types.GetUserPreferencesResponse>;
+    };
+    updateUserPreferences: {
+        (params: NonNullable<Types.UpdateUserPreferencesData['body']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.UpdateUserPreferencesResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.UpdateUserPreferencesErrors;
             response: Response;
             request: Request;
         }>;
+        (params?: NonNullable<Types.UpdateUserPreferencesData['body']>): Promise<Types.UpdateUserPreferencesResponse>;
     };
-    getEpisode: {
-        (options: Options<Types.GetEpisodeData, boolean> & {
+    trackUserActivity: {
+        (params: NonNullable<Types.TrackUserActivityData['body']> & {
             throwOnError: false;
         }): Promise<{
-            data: Types.GetEpisodeResponse;
+            data: Types.TrackUserActivityResponse;
             response: Response;
             request: Request;
         } | {
-            error: Types.GetEpisodeErrors;
+            error: Types.TrackUserActivityErrors;
             response: Response;
             request: Request;
         }>;
-        (options?: Options<Types.GetEpisodeData, boolean>): Promise<{
-            data: Types.GetEpisodeResponse;
+        (params: NonNullable<Types.TrackUserActivityData['body']>): Promise<Types.TrackUserActivityResponse>;
+    };
+    deleteUserActivity: {
+        (params: NonNullable<Types.DeleteUserActivityData['query']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.DeleteUserActivityResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.DeleteUserActivityErrors;
             response: Response;
             request: Request;
         }>;
+        (params?: NonNullable<Types.DeleteUserActivityData['query']>): Promise<Types.DeleteUserActivityResponse>;
     };
-    getSegment: {
-        (options: Options<Types.GetSegmentData, boolean> & {
+    deleteUserActivityByDate: {
+        (id: string): Promise<Types.DeleteUserActivityByDateResponse>;
+        (params: Types.DeleteUserActivityByDateData['path'] & {
             throwOnError: false;
         }): Promise<{
-            data: Types.GetSegmentResponse;
+            data: Types.DeleteUserActivityByDateResponse;
             response: Response;
             request: Request;
         } | {
-            error: Types.GetSegmentErrors;
+            error: Types.DeleteUserActivityByDateErrors;
             response: Response;
             request: Request;
         }>;
-        (options?: Options<Types.GetSegmentData, boolean>): Promise<{
-            data: Types.GetSegmentResponse;
+        (params: Types.DeleteUserActivityByDateData['path']): Promise<Types.DeleteUserActivityByDateResponse>;
+    };
+    deleteUserActivityById: {
+        (id: number): Promise<Types.DeleteUserActivityByIdResponse>;
+        (params: Types.DeleteUserActivityByIdData['path'] & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.DeleteUserActivityByIdResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.DeleteUserActivityByIdErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params: Types.DeleteUserActivityByIdData['path']): Promise<Types.DeleteUserActivityByIdResponse>;
+    };
+    exportUserData: {
+        (params: {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.ExportUserDataResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.ExportUserDataErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (): Promise<Types.ExportUserDataResponse>;
+    };
+    listUserLabs: {
+        (params: {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.ListUserLabsResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.ListUserLabsErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (): Promise<Types.ListUserLabsResponse>;
+    };
+    enrollUserLab: {
+        (id: string): Promise<Types.EnrollUserLabResponse>;
+        (params: Types.EnrollUserLabData['path'] & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.EnrollUserLabResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.EnrollUserLabErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params: Types.EnrollUserLabData['path']): Promise<Types.EnrollUserLabResponse>;
+    };
+    unenrollUserLab: {
+        (id: string): Promise<Types.UnenrollUserLabResponse>;
+        (params: Types.UnenrollUserLabData['path'] & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.UnenrollUserLabResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.UnenrollUserLabErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params: Types.UnenrollUserLabData['path']): Promise<Types.UnenrollUserLabResponse>;
+    };
+    updateCollection: {
+        (id: string): Promise<Types.UpdateCollectionResponse>;
+        (params: Types.UpdateCollectionData['path'] & NonNullable<Types.UpdateCollectionData['body']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.UpdateCollectionResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.UpdateCollectionErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params: Types.UpdateCollectionData['path'] & NonNullable<Types.UpdateCollectionData['body']>): Promise<Types.UpdateCollectionResponse>;
+    };
+    updateCollectionSegment: {
+        (params: Types.UpdateCollectionSegmentData['path'] & NonNullable<Types.UpdateCollectionSegmentData['body']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.UpdateCollectionSegmentResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.UpdateCollectionSegmentErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params: Types.UpdateCollectionSegmentData['path'] & NonNullable<Types.UpdateCollectionSegmentData['body']>): Promise<Types.UpdateCollectionSegmentResponse>;
+    };
+    getCollectionStats: {
+        (id: string): Promise<Types.GetCollectionStatsResponse>;
+        (params: Types.GetCollectionStatsData['path'] & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.GetCollectionStatsResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.GetCollectionStatsErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params: Types.GetCollectionStatsData['path']): Promise<Types.GetCollectionStatsResponse>;
+    };
+    listAdminReports: {
+        (params: NonNullable<Types.ListAdminReportsData['query']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.ListAdminReportsResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.ListAdminReportsErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params?: NonNullable<Types.ListAdminReportsData['query']>): Promise<Types.ListAdminReportsResponse>;
+        paginate: (params?: NonNullable<Types.ListAdminReportsData['query']>) => AsyncGenerator<Types.ListAdminReportsResponse['groups'][number], void, unknown>;
+    };
+    batchUpdateAdminReports: {
+        (params: NonNullable<Types.BatchUpdateAdminReportsData['body']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.BatchUpdateAdminReportsResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.BatchUpdateAdminReportsErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params: NonNullable<Types.BatchUpdateAdminReportsData['body']>): Promise<Types.BatchUpdateAdminReportsResponse>;
+    };
+    bulkUpdateAdminReports: {
+        (params: NonNullable<Types.BulkUpdateAdminReportsData['body']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.BulkUpdateAdminReportsResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.BulkUpdateAdminReportsErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params: NonNullable<Types.BulkUpdateAdminReportsData['body']>): Promise<Types.BulkUpdateAdminReportsResponse>;
+    };
+    bulkDeleteAdminReports: {
+        (params: NonNullable<Types.BulkDeleteAdminReportsData['body']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.BulkDeleteAdminReportsResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.BulkDeleteAdminReportsErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params?: NonNullable<Types.BulkDeleteAdminReportsData['body']>): Promise<Types.BulkDeleteAdminReportsResponse>;
+    };
+    updateAdminReport: {
+        (id: number): Promise<Types.UpdateAdminReportResponse>;
+        (params: Types.UpdateAdminReportData['path'] & NonNullable<Types.UpdateAdminReportData['body']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.UpdateAdminReportResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.UpdateAdminReportErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params: Types.UpdateAdminReportData['path'] & NonNullable<Types.UpdateAdminReportData['body']>): Promise<Types.UpdateAdminReportResponse>;
+    };
+    deleteAdminReport: {
+        (id: number): Promise<Types.DeleteAdminReportResponse>;
+        (params: Types.DeleteAdminReportData['path'] & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.DeleteAdminReportResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.DeleteAdminReportErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params: Types.DeleteAdminReportData['path']): Promise<Types.DeleteAdminReportResponse>;
+    };
+    listAdminMediaAudits: {
+        (params: {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.ListAdminMediaAuditsResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.ListAdminMediaAuditsErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (): Promise<Types.ListAdminMediaAuditsResponse>;
+    };
+    updateAdminMediaAudit: {
+        (id: string): Promise<Types.UpdateAdminMediaAuditResponse>;
+        (params: Types.UpdateAdminMediaAuditData['path'] & NonNullable<Types.UpdateAdminMediaAuditData['body']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.UpdateAdminMediaAuditResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.UpdateAdminMediaAuditErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params: Types.UpdateAdminMediaAuditData['path'] & NonNullable<Types.UpdateAdminMediaAuditData['body']>): Promise<Types.UpdateAdminMediaAuditResponse>;
+    };
+    runAdminMediaAudit: {
+        (id: string): Promise<Types.RunAdminMediaAuditResponse>;
+        (params: Types.RunAdminMediaAuditData['path'] & NonNullable<Types.RunAdminMediaAuditData['query']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.RunAdminMediaAuditResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.RunAdminMediaAuditErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params: Types.RunAdminMediaAuditData['path'] & NonNullable<Types.RunAdminMediaAuditData['query']>): Promise<Types.RunAdminMediaAuditResponse>;
+    };
+    listAdminMediaAuditRuns: {
+        (params: NonNullable<Types.ListAdminMediaAuditRunsData['query']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.ListAdminMediaAuditRunsResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.ListAdminMediaAuditRunsErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params?: NonNullable<Types.ListAdminMediaAuditRunsData['query']>): Promise<Types.ListAdminMediaAuditRunsResponse>;
+        paginate: (params?: NonNullable<Types.ListAdminMediaAuditRunsData['query']>) => AsyncGenerator<Types.ListAdminMediaAuditRunsResponse['runs'][number], void, unknown>;
+    };
+    getAdminMediaAuditRun: {
+        (id: number): Promise<Types.GetAdminMediaAuditRunResponse>;
+        (params: Types.GetAdminMediaAuditRunData['path'] & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.GetAdminMediaAuditRunResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.GetAdminMediaAuditRunErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (params: Types.GetAdminMediaAuditRunData['path']): Promise<Types.GetAdminMediaAuditRunResponse>;
+    };
+    getAnnouncement: {
+        (params: {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.GetAnnouncementResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.GetAnnouncementErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (): Promise<Types.GetAnnouncementResponse>;
+    };
+    updateAnnouncement: {
+        (params: NonNullable<Types.UpdateAnnouncementData['body']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.UpdateAnnouncementResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.UpdateAnnouncementErrors;
             response: Response;
             request: Request;
         }>;
+        (params: NonNullable<Types.UpdateAnnouncementData['body']>): Promise<Types.UpdateAnnouncementResponse>;
     };
 };
 export declare function createNadeshikoClient(config: NadeshikoConfig): NadeshikoClient;