@modrinth/api-client 0.12.0 → 0.14.0

package/dist/modules/archon/server-users/v1.d.ts

@@ -0,0 +1,30 @@
+import { AbstractModule } from '../../../core/abstract-module';
+import type { Archon } from '../types';
+export declare class ArchonServerUsersV1Module extends AbstractModule {
+    getModuleID(): string;
+    /**
+     * Get list of users with access to a server
+     * GET /v1/servers/:server_id/users
+     */
+    list(serverId: string): Promise<Archon.ServerUsers.v1.ServerUser[]>;
+    /**
+     * Add a user to a server
+     * POST /v1/servers/:server_id/users
+     */
+    add(serverId: string, user: Archon.ServerUsers.v1.AddServerUserRequest): Promise<void>;
+    /**
+     * Re-send an invite to a pending server user.
+     * POST /v1/servers/:server_id/users/:user_id/reinvite
+     */
+    reinvite(serverId: string, userId: string): Promise<Archon.ServerUsers.v1.ReinviteResponse>;
+    /**
+     * Remove a user from a server
+     * DELETE /v1/servers/:server_id/users/:user_id
+     */
+    delete(serverId: string, userId: string): Promise<void>;
+    /**
+     * Update a user's server role
+     * PATCH /v1/servers/:server_id/users/:user_id
+     */
+    update(serverId: string, userId: string, role: Archon.ServerUsers.v1.AssignableServerUserRole): Promise<void>;
+}

package/dist/modules/archon/transfers/internal.d.ts

@@ -0,0 +1,25 @@
+import { AbstractModule } from '../../../core/abstract-module';
+import type { Archon } from '../types';
+export declare class ArchonTransfersInternalModule extends AbstractModule {
+    getModuleID(): string;
+    /**
+     * Schedule transfers for specific servers.
+     * POST /_internal/transfers/schedule/servers
+     */
+    scheduleServers(request: Archon.Transfers.Internal.ScheduleServerTransfersRequest): Promise<Archon.Transfers.Internal.ScheduleTransfersResponse>;
+    /**
+     * Schedule transfers for all servers on specific nodes.
+     * POST /_internal/transfers/schedule/nodes
+     */
+    scheduleNodes(request: Archon.Transfers.Internal.ScheduleNodeTransfersRequest): Promise<Archon.Transfers.Internal.ScheduleTransfersResponse>;
+    /**
+     * Get transfer batch history.
+     * GET /_internal/transfers/history
+     */
+    history(options?: Archon.Transfers.Internal.TransferHistoryQuery): Promise<Archon.Transfers.Internal.TransferHistoryResponse>;
+    /**
+     * Cancel pending transfer batches.
+     * POST /_internal/transfers/cancel
+     */
+    cancel(request: Archon.Transfers.Internal.CancelTransfersRequest): Promise<Archon.Transfers.Internal.CancelTransfersResponse>;
+}

package/dist/modules/archon/types.d.ts

@@ -1,5 +1,211 @@
 import type { Labrinth } from '../labrinth/types';
 export declare namespace Archon {
+    namespace Nodes {
+        namespace Internal {
+            type Node = {
+                id: string;
+                hostname: string;
+                region: string;
+                created_at: string | null;
+                locked: boolean;
+            };
+            type Server = {
+                id: string;
+                available: boolean;
+            };
+            type NodeFull = Node & {
+                servers: Server[];
+            };
+            type Overview = {
+                node_hostnames: string[];
+                regions: Region[];
+                total_servers_active: number;
+            };
+            type Region = {
+                display_name: string;
+                country_code: string;
+                key: string;
+                server_count: number;
+                node_count: number;
+            };
+            type RegionWithStatistics = {
+                region: Region;
+                active_servers: string[];
+            };
+        }
+    }
+    namespace Notices {
+        namespace v0 {
+            type Notice = {
+                id: number;
+                dismissable: boolean;
+                title: string | null;
+                message: string;
+                level: string;
+                announced: string;
+            };
+            type ListedNotice = {
+                id: number;
+                dismissable: boolean;
+                message: string;
+                title: string | null;
+                level: string;
+                announce_at: string;
+                expires: string | null;
+                assigned: Assignment[];
+                dismissed_by: Dismisser[];
+            };
+            type Dismisser = {
+                server: string;
+                dismissed_on: string;
+            };
+            type Assignment = {
+                kind: string;
+                id: string;
+                name: string;
+            };
+            type AssignmentTarget = {
+                server: string;
+            } | {
+                node: string;
+            };
+            type Announce = {
+                message: string;
+                title?: string | null;
+                level: string;
+                dismissable: boolean;
+                announce_at: string;
+                expires?: string | null;
+            };
+            type AnnouncePatch = {
+                message?: string;
+                title?: string | null;
+                level?: string;
+                dismissable?: boolean;
+                announce_at?: string;
+                expires?: string | null;
+            };
+            type PostNoticeResponseBody = {
+                id: number;
+            };
+        }
+    }
+    namespace Actions {
+        namespace v1 {
+            type SortOrder = 'asc' | 'desc';
+            type ActionName = 'server_created' | 'changed_server_name' | 'changed_server_subdomain' | 'server_reallocated' | 'server_plan_changed' | 'user_invited' | 'user_invite_revoked' | 'user_permission_modified' | 'user_removed' | 'addon_added' | 'addon_uploaded' | 'addon_disabled' | 'addon_enabled' | 'addon_deleted' | 'addon_updated' | 'modpack_changed' | 'modpack_unlinked' | 'server_repaired' | 'server_reset' | 'server_started' | 'server_stopped' | 'server_restarted' | 'server_killed' | 'port_allocation_added' | 'port_allocation_removed' | 'loader_version_edited' | 'game_version_edited' | 'server_properties_modified' | 'file_uploaded' | 'file_deleted' | 'file_renamed' | 'file_edited' | 'sftp_login' | 'console_command_executed' | 'console_cleared' | 'backup_created' | 'backup_renamed' | 'backup_restored' | 'backup_deleted' | 'startup_command_modified' | 'java_runtime_modified' | 'java_version_modified';
+            type Action = {
+                action: ActionName | string;
+                metadata?: unknown;
+            };
+            type UserPermissionsActionMetadata = {
+                user_id: string;
+                permissions?: ServerUsers.v1.UserScope | null;
+            };
+            type ActionUser = {
+                type: 'user';
+                user_id: string;
+            } | {
+                type: 'support';
+                user_id?: string | null;
+            };
+            type ActionEntry = {
+                actor: ActionUser;
+                action: Action;
+                server_id: string;
+                world_id?: string | null;
+                timestamp: string;
+            };
+            type UserResp = {
+                username: string;
+                avatar_url?: string | null;
+            };
+            type AddonResp = {
+                title: string;
+                slug?: string | null;
+                icon_url?: string | null;
+                version?: string | null;
+            };
+            type VersionResp = {
+                name: string;
+                version_number?: string | null;
+            };
+            type ActionLogResponse = {
+                next_offset?: number | null;
+                data: ActionEntry[];
+                users: Record<string, UserResp>;
+                addons: Record<string, AddonResp>;
+                versions: Record<string, VersionResp>;
+            };
+            type ActionLogFilter = {
+                users?: string[];
+                worlds?: Array<string | null>;
+                actions?: ActionName[];
+            };
+            type ListActionLogOptions = {
+                filter?: ActionLogFilter;
+                limit?: number;
+                offset?: number;
+                order?: SortOrder;
+                min_datetime?: string;
+                max_datetime?: string;
+            };
+        }
+    }
+    namespace Transfers {
+        namespace Internal {
+            type ProvisionOptions = {
+                region?: string | null;
+                node_tags: string[];
+            };
+            type ScheduleServerTransfersRequest = {
+                server_ids: string[];
+                scheduled_at?: string | null;
+                target_region?: string | null;
+                node_tags?: string[];
+                reason?: string | null;
+            };
+            type ScheduleNodeTransfersRequest = {
+                node_hostnames: string[];
+                scheduled_at?: string | null;
+                target_region?: string | null;
+                node_tags?: string[];
+                reason?: string | null;
+                cordon_nodes?: boolean;
+                tag_nodes?: string | null;
+            };
+            type ScheduleTransfersResponse = {
+                batch_id: number;
+                scheduled_count: number;
+            };
+            type CancelTransfersRequest = {
+                batch_ids: number[];
+            };
+            type CancelTransfersResponse = {
+                cancelled_count: number;
+            };
+            type TransferLogBatchEntry = {
+                id: number;
+                created_by: string;
+                created_at: string;
+                reason?: string | null;
+                scheduled_at: string;
+                cancelled: boolean;
+                log_count: number;
+                provision_options: ProvisionOptions;
+            };
+            type TransferHistoryQuery = {
+                page?: number;
+                page_size?: number;
+            };
+            type TransferHistoryResponse = {
+                batches: TransferLogBatchEntry[];
+                total: number;
+                page: number;
+                page_size: number;
+            };
+        }
+    }
     namespace Content {
         namespace v1 {
             type AddonKind = 'mod' | 'plugin' | 'datapack' | 'shader' | 'resourcepack';
@@ -181,11 +387,58 @@ export declare namespace Archon {
             };
         }
     }
+    namespace ServerUsers {
+        namespace v1 {
+            type ServerUserRole = 'Owner' | 'Editor' | 'Viewer' | 'Unknown';
+            type AssignableServerUserRole = Exclude<ServerUserRole, 'Owner' | 'Unknown'>;
+            const UserScope: {
+                readonly NONE: "";
+                readonly SERVER_ADMIN: "SERVER_ADMIN";
+                readonly BASE_READ: "BASE_READ";
+                readonly POWER_ACTIONS: "POWER_ACTIONS";
+                readonly EXEC_COMMANDS: "EXEC_COMMANDS";
+                readonly FILES_WRITE: "FILES_WRITE";
+                readonly SETUP: "SETUP";
+                readonly BACKUPS: "BACKUPS";
+                readonly ADVANCED: "ADVANCED";
+                readonly RESET_SERVER: "RESET_SERVER";
+                readonly MANAGE_USERS: "MANAGE_USERS";
+                readonly SUPPORT_AGENT: "SUPPORT_AGENT";
+                readonly INFRA_MANAGER: "INFRA_MANAGER";
+                readonly INFRA_MANAGER_READ: "INFRA_MANAGER_READ";
+                readonly INFRA_SERVERS_XFER: "INFRA_SERVERS_XFER";
+                readonly INFRA_USERS: "INFRA_USERS";
+            };
+            type UserScope = string | number;
+            type UserResp = {
+                id: string;
+                username: string;
+                avatar_url?: string | null;
+            };
+            type ServerUser = {
+                user: UserResp;
+                added_on?: string | null;
+                last_invite_sent?: string | null;
+                permissions: UserScope;
+            };
+            type AddServerUserRequest = {
+                server_id?: string | null;
+                user_id: string;
+                added_on?: string | null;
+                role: ServerUserRole;
+            };
+            type ReinviteResponse = {
+                sent: boolean;
+                cooldown_seconds: number | null;
+            };
+        }
+    }
     namespace Servers {
         namespace v0 {
             type ServerGetResponse = {
                 servers: Server[];
                 pagination: Pagination;
+                users: Record<string, ServerOwner>;
             };
             type Pagination = {
                 current_page: number;
@@ -193,6 +446,11 @@ export declare namespace Archon {
                 total_pages: number;
                 total_items: number;
             };
+            type ServerOwner = {
+                id: string;
+                username: string;
+                avatar_url?: string | null;
+            };
             type Status = 'installing' | 'broken' | 'available' | 'suspended';
             type SuspensionReason = 'moderated' | 'paymentfailed' | 'cancelled' | 'upgrading' | 'other';
             type Loader = 'Forge' | 'NeoForge' | 'Fabric' | 'Quilt' | 'Purpur' | 'Spigot' | 'Vanilla' | 'Paper';
@@ -220,10 +478,12 @@ export declare namespace Archon {
                 node: NodeInfo | null;
                 flows: Flows;
                 is_medal: boolean;
+                current_user_permissions: UserScope;
                 medal_expires?: string;
             };
+            type UserScope = number;
             type Net = {
-                ip: string;
+                ip: string | null;
                 port: number;
                 domain: string;
             };
@@ -337,9 +597,9 @@ export declare namespace Archon {
                 modloader: string;
                 modloader_version: string;
                 game_version: string;
-                java_version: number;
-                invocation: string;
-                original_invocation: string;
+                java_version: number | null;
+                invocation: string | null;
+                original_invocation: string | null;
             };
             type Region = {
                 shortcode: string;
@@ -409,27 +669,36 @@ export declare namespace Archon {
             type PostBackupQueueResponse = {
                 id: string;
             };
+            type UserInfo = {
+                id: string;
+                username: string;
+                avatar_url: string | null;
+            };
             type DeleteManyBackupRequest = {
                 backup_ids: string[];
             };
             type ActiveOperation = {
                 backup_id: string;
                 operation_type: BackupQueueOperationType;
-                operation_id?: number | null;
+                operation_id: number | null;
                 has_parent: boolean;
                 scheduled_for: string;
+                started_at: string | null;
                 synthetic_legacy: boolean;
+                user_info: UserInfo | null;
             };
             type BackupQueueOperation = {
                 operation_type: BackupQueueOperationType;
-                operation_id?: number | null;
+                operation_id: number | null;
                 state: BackupQueueState;
                 scheduled_for: string;
-                completed_at?: string | null;
+                started_at: string | null;
+                completed_at: string | null;
                 has_parent: boolean;
-                error?: string | null;
+                error: string | null;
                 should_prompt: boolean;
                 synthetic_legacy: boolean;
+                user_info: UserInfo | null;
             };
             type BackupQueueBackup = {
                 id: string;
@@ -446,6 +715,94 @@ export declare namespace Archon {
             };
         }
     }
+    namespace Sync {
+        namespace v1 {
+            type SyncCategory = 'backup' | 'users' | 'server' | 'protocol' | 'world';
+            type SyncIntent = 'all' | SyncCategory | SyncCategory[];
+            type BackupOperationStatus = 'completed' | 'cancelled' | 'failed' | 'timed-out';
+            type ServerNetworkPort = {
+                port: number;
+                name: string;
+            };
+            type ProtocolResetEvent = {
+                type: 'protocol.reset';
+            };
+            type ProtocolInvalidEvent = {
+                type: 'protocol.invalid';
+            };
+            type ProtocolErrorEvent = {
+                type: 'protocol.error';
+                error: string;
+            };
+            type BackupNewEvent = {
+                type: 'backup.new';
+                id: string;
+            };
+            type BackupPatchEvent = {
+                type: 'backup.patch';
+                world_id: string;
+                backup_id: string;
+                name: string;
+            };
+            type BackupDeleteEvent = {
+                type: 'backup.delete';
+                world_id: string;
+                backup_id: string;
+            };
+            type BackupOperationStartEvent = {
+                type: 'backup.operation.create.init' | 'backup.operation.create.start' | 'backup.operation.restore.init' | 'backup.operation.restore.start';
+                world_id: string;
+                backup_id: string;
+                operation_id: number;
+            };
+            type BackupOperationDoneEvent = {
+                type: 'backup.operation.create.done' | 'backup.operation.restore.done';
+                world_id: string;
+                backup_id: string;
+                operation_id: number;
+                status: BackupOperationStatus;
+            };
+            type ServerPatchEvent = {
+                type: 'server.patch';
+                name: string;
+                subdomain: string;
+            };
+            type ServerNetworkPatchEvent = {
+                type: 'server.network.patch';
+                ports: ServerNetworkPort[];
+            };
+            type ServerTransferEvent = {
+                type: 'server.transfer.start' | 'server.transfer.done';
+                target_node: string;
+            };
+            type UsersPatchEvent = {
+                type: 'users.patch';
+            };
+            type WorldPatchEvent = {
+                type: 'world.patch';
+                world_id: string;
+                name: string;
+            };
+            type WorldStartupPatchEvent = {
+                type: 'world.startup.patch';
+                world_id: string;
+                java_version: number | null;
+                invocation: string | null;
+                original_invocation: string | null;
+            };
+            type WorldContentAddonPatchEvent = {
+                type: 'world.content.addon.patch';
+                world_id: string;
+                specs: Archon.Content.v1.Addon[];
+            };
+            type WorldContentBaseUpdateEvent = {
+                type: 'world.content.base.update';
+                world_id: string;
+                spec: Archon.Content.v1.Addons;
+            };
+            type SyncEvent = ProtocolResetEvent | ProtocolInvalidEvent | ProtocolErrorEvent | BackupNewEvent | BackupPatchEvent | BackupDeleteEvent | BackupOperationStartEvent | BackupOperationDoneEvent | ServerPatchEvent | ServerNetworkPatchEvent | ServerTransferEvent | UsersPatchEvent | WorldPatchEvent | WorldStartupPatchEvent | WorldContentAddonPatchEvent | WorldContentBaseUpdateEvent;
+        }
+    }
     namespace Websocket {
         namespace v0 {
             type WSAuth = {

package/dist/modules/index.d.ts

@@ -1,12 +1,17 @@
 import type { AbstractModrinthClient } from '../core/abstract-client';
 import type { AbstractModule } from '../core/abstract-module';
+import { ArchonActionsV1Module } from './archon/actions/v1';
 import { ArchonBackupsV1Module } from './archon/backups/v1';
 import { ArchonBackupsQueueV1Module } from './archon/backups-queue/v1';
 import { ArchonContentV1Module } from './archon/content/v1';
+import { ArchonNodesInternalModule } from './archon/nodes/internal';
+import { ArchonNoticesV0Module } from './archon/notices/v0';
 import { ArchonOptionsV1Module } from './archon/options/v1';
 import { ArchonPropertiesV1Module } from './archon/properties/v1';
+import { ArchonServerUsersV1Module } from './archon/server-users/v1';
 import { ArchonServersV0Module } from './archon/servers/v0';
 import { ArchonServersV1Module } from './archon/servers/v1';
+import { ArchonTransfersInternalModule } from './archon/transfers/internal';
 import { ISO3166Module } from './iso3166';
 import { KyrosContentV1Module } from './kyros/content/v1';
 import { KyrosFilesV0Module } from './kyros/files/v0';
@@ -21,6 +26,7 @@ import { LabrinthBillingInternalModule } from './labrinth/billing/internal';
 import { LabrinthCampaignInternalModule } from './labrinth/campaign/internal';
 import { LabrinthCollectionsModule } from './labrinth/collections';
 import { LabrinthExternalProjectsInternalModule } from './labrinth/external-projects/internal';
+import { LabrinthFriendsV3Module } from './labrinth/friends/v3';
 import { LabrinthGlobalsInternalModule } from './labrinth/globals/internal';
 import { LabrinthLimitsV3Module } from './labrinth/limits/v3';
 import { LabrinthModerationInternalModule } from './labrinth/moderation/internal';
@@ -59,13 +65,18 @@ type ModuleConstructor = new (client: AbstractModrinthClient) => AbstractModule;
  * TODO: Better way? Probably not
  */
 export declare const MODULE_REGISTRY: {
+    readonly archon_actions_v1: typeof ArchonActionsV1Module;
     readonly archon_backups_queue_v1: typeof ArchonBackupsQueueV1Module;
     readonly archon_backups_v1: typeof ArchonBackupsV1Module;
     readonly archon_content_v1: typeof ArchonContentV1Module;
+    readonly archon_nodes_internal: typeof ArchonNodesInternalModule;
+    readonly archon_notices_v0: typeof ArchonNoticesV0Module;
     readonly archon_options_v1: typeof ArchonOptionsV1Module;
     readonly archon_properties_v1: typeof ArchonPropertiesV1Module;
+    readonly archon_server_users_v1: typeof ArchonServerUsersV1Module;
     readonly archon_servers_v0: typeof ArchonServersV0Module;
     readonly archon_servers_v1: typeof ArchonServersV1Module;
+    readonly archon_transfers_internal: typeof ArchonTransfersInternalModule;
     readonly iso3166_data: typeof ISO3166Module;
     readonly mclogs_insights_v1: typeof MclogsInsightsV1Module;
     readonly mclogs_logs_v1: typeof MclogsLogsV1Module;
@@ -82,6 +93,7 @@ export declare const MODULE_REGISTRY: {
     readonly labrinth_campaign_internal: typeof LabrinthCampaignInternalModule;
     readonly labrinth_collections: typeof LabrinthCollectionsModule;
     readonly labrinth_external_projects_internal: typeof LabrinthExternalProjectsInternalModule;
+    readonly labrinth_friends_v3: typeof LabrinthFriendsV3Module;
     readonly labrinth_globals_internal: typeof LabrinthGlobalsInternalModule;
     readonly labrinth_moderation_internal: typeof LabrinthModerationInternalModule;
     readonly labrinth_notifications_v2: typeof LabrinthNotificationsV2Module;

package/dist/modules/labrinth/friends/v3.d.ts

@@ -0,0 +1,23 @@
+import { AbstractModule } from '../../../core/abstract-module';
+import type { Labrinth } from '../types';
+export declare class LabrinthFriendsV3Module extends AbstractModule {
+    getModuleID(): string;
+    /**
+     * Get friends and pending friend requests for the authenticated user
+     *
+     * @returns Promise resolving to friend relationships
+     */
+    list(): Promise<Labrinth.Friends.v3.UserFriend[]>;
+    /**
+     * Send or accept a friend request
+     *
+     * @param idOrUsername - The target user's ID or username
+     */
+    add(idOrUsername: string): Promise<void>;
+    /**
+     * Remove a friend or pending friend request
+     *
+     * @param idOrUsername - The target user's ID or username
+     */
+    remove(idOrUsername: string): Promise<void>;
+}

package/dist/modules/labrinth/index.d.ts

@@ -4,6 +4,7 @@ export * from './auth/v2';
 export * from './billing/internal';
 export * from './collections';
 export * from './external-projects/internal';
+export * from './friends/v3';
 export * from './globals/internal';
 export * from './limits/v3';
 export * from './moderation/internal';

package/dist/modules/labrinth/types.d.ts

@@ -1124,12 +1124,27 @@ export declare namespace Labrinth {
                 moderation_notes?: Common.ModerationNote | null;
                 github_id?: number;
             };
+            type SearchUser = {
+                id: string;
+                username: string;
+                avatar_url: string | null;
+            };
             type AllProjectsResponse = {
                 projects: Projects.v3.Project[];
                 organizations: Record<string, Organizations.v3.Organization>;
             };
         }
     }
+    namespace Friends {
+        namespace v3 {
+            type UserFriend = {
+                id: string;
+                friend_id: string;
+                accepted: boolean;
+                created: string;
+            };
+        }
+    }
     namespace ServerPing {
         namespace Internal {
             type MinecraftJavaPingRequest = {

package/dist/modules/labrinth/users/v3.d.ts

@@ -16,6 +16,15 @@ export declare class LabrinthUsersV3Module extends AbstractModule {
      * GET /v3/user/{id}
      */
     get(idOrUsername: string): Promise<Labrinth.Users.v3.User>;
+    /**
+     * Search users by username prefix.
+     *
+     * @param query - Username search query
+     * @returns Promise resolving to compact user search results
+     *
+     * GET /v3/users/search?query=:query
+     */
+    search(query: string): Promise<Labrinth.Users.v3.SearchUser[]>;
     /**
      * Get all projects the authenticated user can access directly or through
      * their organizations.

package/dist/platform/generic.d.ts

@@ -1,4 +1,4 @@
-import type { ModrinthApiError } from '../core/errors';
+import { ModrinthApiError } from '../core/errors';
 import type { ClientConfig } from '../types/client';
 import type { RequestOptions } from '../types/request';
 import { XHRUploadClient } from './xhr-upload-client';
@@ -23,5 +23,6 @@ import { XHRUploadClient } from './xhr-upload-client';
 export declare class GenericModrinthClient extends XHRUploadClient {
     constructor(config: ClientConfig);
     protected executeRequest<T>(url: string, options: RequestOptions): Promise<T>;
+    protected executeStreamRequest(url: string, options: RequestOptions): Promise<ReadableStream<Uint8Array>>;
     protected normalizeError(error: unknown): ModrinthApiError;
 }

package/dist/platform/nuxt.d.ts

@@ -82,6 +82,7 @@ export declare class NuxtModrinthClient extends XHRUploadClient {
      */
     upload<T = void>(path: string, options: UploadRequestOptions): UploadHandle<T>;
     protected executeRequest<T>(url: string, options: RequestOptions): Promise<T>;
+    protected executeStreamRequest(url: string, options: RequestOptions): Promise<ReadableStream<Uint8Array>>;
     protected normalizeError(error: unknown): ModrinthApiError;
     protected buildDefaultHeaders(): Promise<Record<string, string>>;
 }

package/dist/platform/sync-generic.d.ts

@@ -0,0 +1,16 @@
+import { AbstractSyncClient, type SyncConnectOptions, type SyncEmitterEvents } from '../core/abstract-sync';
+export declare class GenericSyncClient extends AbstractSyncClient {
+    protected emitter: import("mitt").Emitter<SyncEmitterEvents>;
+    safeConnectServer(serverId: string, options?: SyncConnectOptions): Promise<void>;
+    disconnect(serverId: string): void;
+    disconnectAll(): void;
+    private runConnection;
+    private consumeStream;
+    private processParsedItems;
+    private waitForReconnect;
+    private closeConnection;
+    private getReconnectDelay;
+    private updateLastEventId;
+    private intentToParam;
+    private isAbortError;
+}

package/dist/platform/tauri.d.ts

@@ -30,5 +30,6 @@ export declare class TauriModrinthClient extends XHRUploadClient {
     protected config: TauriClientConfig;
     constructor(config: TauriClientConfig);
     protected executeRequest<T>(url: string, options: RequestOptions): Promise<T>;
+    protected executeStreamRequest(url: string, options: RequestOptions): Promise<ReadableStream<Uint8Array>>;
     protected normalizeError(error: unknown): ModrinthApiError;
 }