@modrinth/api-client 0.90.0 → 0.92.0

package/dist/index.d.ts

@@ -3469,6 +3469,7 @@ export declare namespace Labrinth {
             export type ProjectType = 'mod' | 'modpack' | 'resourcepack' | 'shader' | 'plugin' | 'datapack';
             export type Environment = 'client_and_server' | 'client_only' | 'client_only_server_optional' | 'singleplayer_only' | 'server_only' | 'server_only_client_optional' | 'dedicated_server_only' | 'client_or_server' | 'client_or_server_prefers_both' | 'unknown';
             export type GalleryItem = {
+                id?: number;
                 url: string;
                 raw_url: string;
                 featured: boolean;
@@ -3620,7 +3621,7 @@ export declare namespace Labrinth {
                 side_types_migration_review_status?: 'reviewed' | 'pending';
                 environment?: Environment;
                 minecraft_server?: MinecraftServer;
-                minecraft_java_server?: MinecraftJavaServer;
+                minecraft_java_server?: Omit<MinecraftJavaServer, 'ping'>;
                 minecraft_bedrock_server?: MinecraftBedrockServer;
                 [key: string]: unknown;
             };
@@ -4275,6 +4276,235 @@ export declare namespace Labrinth {
     export namespace Threads {
         export namespace v3 {
             export type ThreadType = 'report' | 'project' | 'direct_message';
+            export type TextTarget = {
+                original: string;
+                suggestion?: string | null;
+            };
+            export type OptionalTextTarget = {
+                original?: string | null;
+                /** Omitted means no suggestion; null suggests removing the value. */
+                suggestion?: string | null;
+            };
+            export type DisclosureMetadata<T extends Projects.v3.ProjectDisclosureType> = Omit<Extract<Projects.v3.ProjectDisclosure, {
+                type: T;
+            }>, 'type'>;
+            export type DisclosureMetadataTarget<T extends Projects.v3.ProjectDisclosureType> = {
+                original: DisclosureMetadata<T> | null;
+                suggestion?: DisclosureMetadata<T> | null;
+            };
+            export type ModifyDisclosureTarget = {
+                [T in Projects.v3.ProjectDisclosureType]: {
+                    type: 'modify_project_disclosure';
+                    value: {
+                        disclosure_type: T;
+                        metadata: DisclosureMetadataTarget<T>;
+                    };
+                };
+            }[Projects.v3.ProjectDisclosureType];
+            export type VersionIssueTarget = {
+                type: 'remove';
+            } | {
+                type: 'modify_environment';
+                value: TextTarget;
+            } | {
+                type: 'modify_game_versions';
+                value: {
+                    original: string[];
+                    suggestion?: string[] | null;
+                };
+            } | {
+                type: 'modify_dependencies';
+                value: {
+                    original: Versions.v3.Dependency[];
+                    suggestion?: Versions.v3.Dependency[] | null;
+                };
+            } | {
+                type: 'modify_changelog';
+                value: TextTarget;
+            } | {
+                type: 'remove_additional_files';
+                value: {
+                    file_ids: string[];
+                };
+            } | {
+                type: 'modify_additional_file_type';
+                value: {
+                    file_id: string;
+                    filename: string;
+                    original?: Versions.v3.FileType | null;
+                    suggestion?: Versions.v3.FileType | null;
+                };
+            };
+            export type ThreadIssueTarget = {
+                type: 'mark_addressed';
+            } | {
+                type: 'modify_title';
+                value: TextTarget;
+            } | {
+                type: 'modify_slug';
+                value: TextTarget;
+            } | {
+                type: 'modify_summary';
+                value: TextTarget;
+            } | {
+                type: 'modify_description';
+                value: TextTarget;
+            } | {
+                type: 'modify_license';
+                value: {
+                    license: TextTarget;
+                    url: TextTarget;
+                };
+            } | {
+                type: 'modify_icon';
+                value: {
+                    original_url: string | null;
+                };
+            } | {
+                type: 'remove_icon';
+            } | {
+                type: 'remove_tags';
+                value: {
+                    tags: string[];
+                };
+            } | {
+                type: 'modify_links';
+                value: {
+                    links: Record<string, TextTarget>;
+                };
+            } | {
+                type: 'add_gallery_images';
+                value: {
+                    original_image_ids: number[];
+                    auto_resolve: boolean;
+                };
+            } | {
+                type: 'modify_gallery_image';
+                value: {
+                    image_id: number;
+                    original_url: string;
+                    name?: OptionalTextTarget | null;
+                    description?: OptionalTextTarget | null;
+                };
+            } | {
+                type: 'remove_gallery_images';
+                value: {
+                    image_ids: number[];
+                    original_images?: {
+                        id: number;
+                        url: string;
+                        name?: string;
+                    }[];
+                };
+            } | {
+                type: 'add_project_disclosures';
+                value: {
+                    disclosure_types: string[];
+                };
+            } | {
+                type: 'remove_project_disclosures';
+                value: {
+                    disclosure_types: string[];
+                };
+            } | ModifyDisclosureTarget | {
+                type: 'modify_project_disclosure_note';
+                value: {
+                    disclosure_type: string;
+                    note: OptionalTextTarget;
+                };
+            } | {
+                type: 'version';
+                value: {
+                    version_id: string;
+                    version_number: string;
+                    target: VersionIssueTarget;
+                };
+            } | {
+                type: 'modify_team_member_role';
+                value: {
+                    team_id: string;
+                    user_id: string;
+                    role: TextTarget;
+                };
+            } | {
+                type: 'modify_server_languages';
+                value: {
+                    original: string[];
+                    suggestion?: string[] | null;
+                };
+            } | {
+                type: 'modify_server_address';
+                value: {
+                    platform: 'minecraft_java' | 'minecraft_bedrock';
+                    address: TextTarget;
+                };
+            } | {
+                type: 'acknowledge';
+                value: {
+                    mode: 'checkbox' | 'reply';
+                };
+            };
+            export type NewThreadIssueFacet = {
+                what: ThreadIssueTarget;
+            };
+            export type ThreadIssueLocation = {
+                field: 'title' | 'slug' | 'summary' | 'icon' | 'description' | 'license' | 'tags' | 'links' | 'gallery' | 'disclosures' | 'versions' | 'members' | 'server' | 'permissions';
+                label?: {
+                    id: string;
+                    defaultMessage?: string;
+                };
+            };
+            /**
+             * The backend stores `why` as an arbitrary JSON blob; this schema is interpreted by the frontend.
+             * Fields are optional to support issues created before review metadata was added.
+             */
+            export type ThreadIssueWhy = {
+                issue_id?: string;
+                /**
+                 * this is to indicate where to show issue card if the issue facet(action) does not have a specific location.
+                 */
+                locations?: ThreadIssueLocation[];
+                title?: string;
+                message?: string;
+                custom?: {
+                    priority: string;
+                };
+                /**
+                 * this is the state of the issue, at creation time.used for re - rev
+                 */
+                selection?: {
+                    toggle_ids: string[];
+                    text_values: Record<string, string>;
+                    select_values: Record<string, string[]>;
+                };
+            };
+            export type NewThreadIssue = {
+                why: ThreadIssueWhy;
+                facets: [NewThreadIssueFacet, ...NewThreadIssueFacet[]];
+            };
+            export type NewThreadIssues = {
+                issues: [NewThreadIssue, ...NewThreadIssue[]];
+            };
+            export type ThreadIssueVerdict = 'open' | 'addressed' | 'resolved';
+            export type ThreadIssueFacet = {
+                id: string;
+                what: ThreadIssueTarget;
+                user_addressed: boolean;
+                moderator_verified: boolean;
+                verdict: ThreadIssueVerdict;
+            };
+            export type ThreadIssue = {
+                id: string;
+                created_by: string | null;
+                created_at: string;
+                why: ThreadIssueWhy;
+                facets: ThreadIssueFacet[];
+                verdict: ThreadIssueVerdict;
+            };
+            export type EditThreadIssueFacet = {
+                user_addressed?: boolean;
+                moderator_verified?: boolean;
+            };
             export type MessageBody = {
                 type: 'text';
                 body: string;
@@ -4285,6 +4515,10 @@ export declare namespace Labrinth {
                 type: 'status_change';
                 new_status: Projects.v2.ProjectStatus;
                 old_status: Projects.v2.ProjectStatus;
+            } | {
+                type: 'auto_approval';
+                new_status: Projects.v2.ProjectStatus;
+                old_status: Projects.v2.ProjectStatus;
             } | {
                 type: 'tech_review';
                 verdict: 'safe' | 'unsafe';
@@ -4324,6 +4558,7 @@ export declare namespace Labrinth {
                 project_id: string | null;
                 report_id: string | null;
                 messages: ThreadMessage[];
+                issues: ThreadIssue[];
                 members: ThreadMember[];
             };
             export type SendMessageRequest = {
@@ -4556,6 +4791,7 @@ export declare namespace Labrinth {
             homePageProjects?: Projects.v2.Project[];
             homePageSearch?: Search.v2.SearchResults;
             homePageNotifs?: Search.v2.SearchResults;
+            prideProjectIds?: string[];
             products?: Billing.Internal.Product[];
             countries: ISO3166.Country[];
             subdivisions: Record<string, ISO3166.Subdivision[]>;
@@ -4604,6 +4840,13 @@ export declare namespace Labrinth {
     }
     export namespace TechReview {
         export namespace Internal {
+            export type FlaggedProject = {
+                project_id: string;
+                thread_id: string;
+                status: Projects.v3.Project['status'];
+                message_id: string;
+                reviewed: string;
+            };
             export type DelphiRule = {
                 id: number;
                 name: string;
@@ -5479,7 +5722,7 @@ declare class LabrinthModerationInternalModule extends AbstractModule {
     getProjectIds(params?: Omit<Labrinth.Moderation.Internal.ProjectsRequest, 'count' | 'offset'>): Promise<Labrinth.Moderation.Internal.ProjectIdsResponse>;
     acquireLock(projectId: string): Promise<Labrinth.Moderation.Internal.LockAcquireResponse>;
     overrideLock(projectId: string): Promise<Labrinth.Moderation.Internal.LockAcquireResponse>;
-    releaseLock(projectId: string): Promise<Labrinth.Moderation.Internal.ReleaseLockResponse>;
+    releaseLock(projectId: string, token?: string): Promise<Labrinth.Moderation.Internal.ReleaseLockResponse>;
     checkLock(projectId: string): Promise<Labrinth.Moderation.Internal.LockStatusResponse>;
     lockUser(userId: string, reason: string): Promise<void>;
     unlockUser(userId: string): Promise<void>;
@@ -6441,6 +6684,8 @@ declare class LabrinthTechReviewInternalModule extends AbstractModule {
      * @returns The project report (may be null if no reports exist) and the moderation thread
      */
     getProjectReport(projectId: string): Promise<Labrinth.TechReview.Internal.ProjectReportResponse>;
+    getUsersFlaggedProjects(userIds: string[]): Promise<Record<string, Labrinth.TechReview.Internal.FlaggedProject[]>>;
+    getOrganizationFlaggedProjects(organizationId: string): Promise<Labrinth.TechReview.Internal.FlaggedProject[]>;
 }
 
 declare class LabrinthThreadsV3Module extends AbstractModule {
@@ -6485,6 +6730,14 @@ declare class LabrinthThreadsV3Module extends AbstractModule {
      * ```
      */
     sendMessage(id: string, message: Labrinth.Threads.v3.SendMessageRequest): Promise<void>;
+    /** Create moderation issues in a thread (requires THREAD_WRITE scope). */
+    createIssues(id: string, data: Labrinth.Threads.v3.NewThreadIssues): Promise<void>;
+    /** Update a thread issue facet's addressed or verified state. */
+    editIssueFacet(id: string, data: Labrinth.Threads.v3.EditThreadIssueFacet): Promise<void>;
+    /** Mark a thread issue facet as addressed by the project member. */
+    user_addressed(facetId: string): Promise<void>;
+    /** Mark a thread issue facet as verified by a moderator. */
+    moderator_verified(facetId: string): Promise<void>;
     /**
      * Delete a message from a thread (v3)
      *