@modrinth/api-client 0.94.0 → 0.96.0

package/dist/index.d.ts

@@ -861,15 +861,6 @@ export declare namespace Archon {
                 limit?: number;
                 offset?: number;
             };
-            export type StockRequest = {
-                cpu?: number;
-                memory_mb?: number;
-                swap_mb?: number;
-                storage_mb?: number;
-            };
-            export type StockResponse = {
-                available: number;
-            };
             export type JWTAuth = {
                 url: string;
                 token: string;
@@ -973,6 +964,25 @@ export declare namespace Archon {
                 lon: number;
                 zone: string;
             };
+            export type MemorySizeStock = {
+                /** Number of servers of this memory size that fit in the region */
+                available: number;
+                /** Hostnames of the nodes which fit at least one server of this memory size */
+                hostnames: string[];
+            };
+            export type RegionStock = {
+                /** Shortcode of the region */
+                region: string;
+                /** Stock of each requested memory size, keyed by memory size in MB */
+                stock: Record<number, MemorySizeStock>;
+                /** WebSocket URLs of random nodes in the region, to measure the latency to it */
+                ping_urls: string[];
+            };
+            export type StockResponse = {
+                regions: RegionStock[];
+                /** Number of servers that fit across all regions, keyed by memory size in MB */
+                total: Record<number, number>;
+            };
         }
     }
     export namespace Backups {
@@ -1071,12 +1081,32 @@ export declare namespace Archon {
                 status: BackupStatus;
                 locked: boolean;
                 automated: boolean;
+                rotates_at?: string;
                 history: BackupQueueOperation[];
             };
             export type BackupsQueueResponse = {
                 active_operations: ActiveOperation[];
                 backups: BackupQueueBackup[];
             };
+            export type WorldBackupOptions = {
+                split_automatic: number;
+                split_manual: number;
+                limit: number;
+                interval: number;
+            };
+            export type BackupsQueueWithOptionsResponse = BackupsQueueResponse & {
+                options: WorldBackupOptions;
+                next_auto_backup_at: string | null;
+            };
+            export type PatchWorldBackupOptions = {
+                split_automatic?: number;
+                split_manual?: number;
+                interval?: number;
+            };
+            export type PatchWorldBackupOptionsResponse = {
+                applied: boolean;
+                backup_ids?: string[];
+            };
         }
     }
     export namespace Sync {
@@ -1422,6 +1452,10 @@ declare class ArchonBackupsQueueV1Module extends AbstractModule {
     getModuleID(): string;
     /** GET /v1/servers/:server_id/worlds/:world_id/backups-queue */
     list(serverId: string, worldId: string): Promise<Archon.BackupsQueue.v1.BackupsQueueResponse>;
+    /** GET /v1/servers/:server_id/worlds/:world_id/backups-queue/with-options */
+    listWithOptions(serverId: string, worldId: string): Promise<Archon.BackupsQueue.v1.BackupsQueueWithOptionsResponse>;
+    /** PATCH /v1/servers/:server_id/worlds/:world_id/backups-queue/with-options */
+    patchOptions(serverId: string, worldId: string, request: Archon.BackupsQueue.v1.PatchWorldBackupOptions, acknowledgeRotation?: boolean): Promise<Archon.BackupsQueue.v1.PatchWorldBackupOptionsResponse>;
     /** POST /v1/servers/:server_id/worlds/:world_id/backups-queue */
     create(serverId: string, worldId: string, request: Archon.BackupsQueue.v1.BackupRequest): Promise<Archon.BackupsQueue.v1.PostBackupQueueResponse>;
     /** POST /v1/servers/:server_id/worlds/:world_id/backups-queue/history/create/:operation_id/ack */
@@ -1640,16 +1674,6 @@ declare class ArchonServersV0Module extends AbstractModule {
      * GET /modrinth/v0/servers
      */
     list(options?: Archon.Servers.v0.GetServersOptions): Promise<Archon.Servers.v0.ServerGetResponse>;
-    /**
-     * Check stock availability for a region
-     * POST /modrinth/v0/stock?region=:region
-     */
-    checkStock(region: string, request: Archon.Servers.v0.StockRequest): Promise<Archon.Servers.v0.StockResponse>;
-    /**
-     * Check stock availability (without region filter)
-     * POST /modrinth/v0/stock
-     */
-    checkStockGlobal(request: Archon.Servers.v0.StockRequest): Promise<Archon.Servers.v0.StockResponse>;
     /**
      * Get filesystem authentication credentials for a server
      * Returns URL and JWT token for accessing the server's filesystem via Kyros
@@ -1770,6 +1794,16 @@ declare class ArchonServersV1Module extends AbstractModule {
      * GET /v1/regions
      */
     getRegions(): Promise<Archon.Servers.v1.Region[]>;
+    /**
+     * Get how many servers of each memory size fit in every public region
+     * GET /v1/stock
+     */
+    getStock(memoryMb: number[]): Promise<Archon.Servers.v1.StockResponse>;
+    /**
+     * Get how many servers of each memory size fit in every public region when upgrading a server
+     * GET /v1/servers/:server_id/upgrade-stock
+     */
+    getUpgradeStock(serverId: string, memoryMb: number[]): Promise<Archon.Servers.v1.StockResponse>;
     /**
      * End the intro flow for a server
      * DELETE /v1/servers/:id/flows/intro
@@ -2304,6 +2338,14 @@ export declare namespace Kyros {
             }
         }
     }
+    export namespace Backups {
+        export namespace v1 {
+            export type BackupDumpFormat = 'zip';
+            export interface BackupDownloadAuthorization {
+                token: string;
+            }
+        }
+    }
     export namespace Files {
         export namespace v1 {
             export interface FileDownloadAuthorization {
@@ -2363,6 +2405,18 @@ export declare namespace Kyros {
     }
 }
 
+declare class KyrosBackupsV1Module extends AbstractModule {
+    getModuleID(): string;
+    /**
+     * Authorize a short-lived, single-use backup download.
+     */
+    authorizeDownload(nodeUrlHost: string, worldId: string, backupId: string, format?: Kyros.Backups.v1.BackupDumpFormat): Promise<Kyros.Backups.v1.BackupDownloadAuthorization>;
+    /**
+     * Build the browser URL for a previously authorized backup download.
+     */
+    getDownloadUrl(nodeUrlHost: string, worldId: string, backupId: string, token: string): string;
+}
+
 declare class KyrosContentV1Module extends AbstractModule {
     getModuleID(): string;
     /**
@@ -7374,6 +7428,7 @@ declare const MODULE_REGISTRY: {
     readonly mclogs_insights_v1: typeof MclogsInsightsV1Module;
     readonly mclogs_logs_v1: typeof MclogsLogsV1Module;
     readonly launchermeta_manifest_v0: typeof LauncherMetaManifestV0Module;
+    readonly kyros_backups_v1: typeof KyrosBackupsV1Module;
     readonly kyros_content_v1: typeof KyrosContentV1Module;
     readonly kyros_files_v0: typeof KyrosFilesV0Module;
     readonly kyros_files_v1: typeof KyrosFilesV1Module;
@@ -7661,8 +7716,6 @@ declare type ParseModule<T extends string, API extends string> = T extends `${AP
 
 export declare function parseSyncEventData(data: string): Archon.Sync.v1.SyncEvent | null;
 
-export declare function pingWebSocketUrl(url: string, options?: WebSocketPingOptions): Promise<number>;
-
 export declare namespace Purpur {
     export namespace Versions {
         export namespace v2 {
@@ -8213,11 +8266,30 @@ export declare interface WebSocketConnection {
 
 export declare type WebSocketEventHandler<E extends Archon.Websocket.v0.WSEvent = Archon.Websocket.v0.WSEvent> = (event: E) => void;
 
+/**
+ * Measures the latency to a ping test WebSocket, which echoes back every message. The connection stays open between
+ * measurements until {@link WebSocketPinger.close} is called.
+ */
+export declare class WebSocketPinger {
+    /** Resolves to whether the connection opened within the connect timeout. */
+    readonly connected: Promise<boolean>;
+    private readonly socket;
+    private sampleListener;
+    private closed;
+    constructor(url: string, connectTimeoutMs: number);
+    get isOpen(): boolean;
+    /**
+     * Sends `count` pings over the connection and resolves to the latency in ms of every ping that came back, once
+     * all of them came back or `settleDelayMs` after the last one was sent.
+     */
+    measure(options?: WebSocketPingOptions): Promise<number[]>;
+    close(): void;
+}
+
 export declare interface WebSocketPingOptions {
     count?: number;
     intervalMs?: number;
     settleDelayMs?: number;
-    timeoutMs?: number;
     signal?: AbortSignal;
 }