@brigadasos/nadeshiko-sdk 2.2.0 → 2.2.1-internal.53bb652

package/dist/internal/admin.gen.d.ts

@@ -0,0 +1,2 @@
+export { listAdminReports, batchUpdateAdminReports, bulkUpdateAdminReports, bulkDeleteAdminReports, updateAdminReport, deleteAdminReport, listAdminMediaAudits, updateAdminMediaAudit, runAdminMediaAudit, listAdminMediaAuditRuns, getAdminMediaAuditRun, getAnnouncement, updateAnnouncement } from '../sdk.gen';
+//# sourceMappingURL=admin.gen.d.ts.map

package/dist/internal/admin.gen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin.gen.d.ts","sourceRoot":"","sources":["../../../../generated/internal/internal/admin.gen.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC"}

package/dist/internal/collections.gen.d.ts

@@ -0,0 +1,2 @@
+export { updateCollection, updateCollectionSegment, getCollectionStats } from '../sdk.gen';
+//# sourceMappingURL=collections.gen.d.ts.map

package/dist/internal/collections.gen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collections.gen.d.ts","sourceRoot":"","sources":["../../../../generated/internal/internal/collections.gen.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC"}

package/dist/internal/media.gen.d.ts

@@ -0,0 +1,2 @@
+export { createMedia, updateSegment, listSegmentRevisions, updateMedia, deleteMedia, createEpisode, updateEpisode, deleteEpisode, listSegments, createSegment, createSegmentsBatch } from '../sdk.gen';
+//# sourceMappingURL=media.gen.d.ts.map

package/dist/internal/media.gen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media.gen.d.ts","sourceRoot":"","sources":["../../../../generated/internal/internal/media.gen.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,oBAAoB,EAAE,WAAW,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,aAAa,EAAE,YAAY,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC"}

package/dist/internal/stats.gen.d.ts

@@ -0,0 +1,2 @@
+export { getCoveredWords, triggerCoveredWordsUpdate } from '../sdk.gen';
+//# sourceMappingURL=stats.gen.d.ts.map

package/dist/internal/stats.gen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stats.gen.d.ts","sourceRoot":"","sources":["../../../../generated/internal/internal/stats.gen.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC"}

package/dist/internal/user.gen.d.ts

@@ -0,0 +1,2 @@
+export { createUserReport, getUserPreferences, updateUserPreferences, trackUserActivity, deleteUserActivity, deleteUserActivityByDate, deleteUserActivityById, exportUserData, listUserLabs, enrollUserLab, unenrollUserLab } from '../sdk.gen';
+//# sourceMappingURL=user.gen.d.ts.map

package/dist/internal/user.gen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user.gen.d.ts","sourceRoot":"","sources":["../../../../generated/internal/internal/user.gen.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,sBAAsB,EAAE,cAAc,EAAE,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC"}

package/dist/internal.gen.d.ts

@@ -0,0 +1,6 @@
+export * as stats from './internal/stats.gen';
+export * as media from './internal/media.gen';
+export * as user from './internal/user.gen';
+export * as collections from './internal/collections.gen';
+export * as admin from './internal/admin.gen';
+//# sourceMappingURL=internal.gen.d.ts.map

package/dist/internal.gen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.gen.d.ts","sourceRoot":"","sources":["../../../generated/internal/internal.gen.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,MAAM,sBAAsB,CAAC;AAC9C,OAAO,KAAK,KAAK,MAAM,sBAAsB,CAAC;AAC9C,OAAO,KAAK,IAAI,MAAM,qBAAqB,CAAC;AAC5C,OAAO,KAAK,WAAW,MAAM,4BAA4B,CAAC;AAC1D,OAAO,KAAK,KAAK,MAAM,sBAAsB,CAAC"}

package/dist/nadeshiko.gen.d.ts

@@ -1,9 +1,19 @@
 import { type Client } from './client';
 import type * as Types from './types.gen';
 import { type RetryOptions } from './retry';
+type ApiKeyProvider = string | (() => string | undefined | Promise<string | undefined>);
 export interface NadeshikoConfig {
-    /** API key for Nadeshiko API authentication. */
-    apiKey: string;
+    /**
+     * API key for Bearer token 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'`, `'STAGING'`, `'PRODUCTION'`, or a custom URL string. */
     baseURL?: 'LOCAL' | 'DEVELOPMENT' | 'STAGING' | 'PRODUCTION' | string;
     /** @deprecated Use `baseURL` instead */
@@ -379,6 +389,586 @@ export type NadeshikoClient = {
         }>;
         (params: Types.RemoveSegmentFromCollectionData['path']): Promise<Types.RemoveSegmentFromCollectionResponse>;
     };
+    getCoveredWords: {
+        (params: NonNullable<Types.GetCoveredWordsData['query']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.GetCoveredWordsResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.GetCoveredWordsErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (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>;
+    };
+    createMedia: {
+        (params: NonNullable<Types.CreateMediaData['body']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.CreateMediaResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.CreateMediaErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (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>;
+    };
+    listSegmentRevisions: {
+        (id: string): Promise<Types.ListSegmentRevisionsResponse>;
+        (params: Types.ListSegmentRevisionsData['path'] & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.ListSegmentRevisionsResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.ListSegmentRevisionsErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (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>;
+    };
+    deleteMedia: {
+        (id: string): Promise<Types.DeleteMediaResponse>;
+        (params: Types.DeleteMediaData['path'] & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.DeleteMediaResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.DeleteMediaErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (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>;
+    };
+    updateEpisode: {
+        (params: Types.UpdateEpisodeData['path'] & NonNullable<Types.UpdateEpisodeData['body']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.UpdateEpisodeResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.UpdateEpisodeErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (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>;
+    };
+    listSegments: {
+        (params: Types.ListSegmentsData['path'] & NonNullable<Types.ListSegmentsData['query']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.ListSegmentsResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.ListSegmentsErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (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>;
+    };
+    createSegmentsBatch: {
+        (params: Types.CreateSegmentsBatchData['path'] & NonNullable<Types.CreateSegmentsBatchData['body']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.CreateSegmentsBatchResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.CreateSegmentsBatchErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (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>;
+    };
+    getUserPreferences: {
+        (params: {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.GetUserPreferencesResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.GetUserPreferencesErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (): 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>;
+    };
+    trackUserActivity: {
+        (params: NonNullable<Types.TrackUserActivityData['body']> & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.TrackUserActivityResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.TrackUserActivityErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (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>;
+    };
+    deleteUserActivityByDate: {
+        (id: string): Promise<Types.DeleteUserActivityByDateResponse>;
+        (params: Types.DeleteUserActivityByDateData['path'] & {
+            throwOnError: false;
+        }): Promise<{
+            data: Types.DeleteUserActivityByDateResponse;
+            response: Response;
+            request: Request;
+        } | {
+            error: Types.DeleteUserActivityByDateErrors;
+            response: Response;
+            request: Request;
+        }>;
+        (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;
+export {};
 //# sourceMappingURL=nadeshiko.gen.d.ts.map