pterodactyl-api-client 3.4.1 → 4.1.0

package/dist/client/server/server.manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.manager.d.ts","sourceRoot":"","sources":["../../../src/client/server/server.manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAElE,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAEnE,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEjD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAIlE,qBAAa,mBAAoB,SAAQ,gBAAgB,CACvD,MAAM,EACN,YAAY,CACb;IAEG,OAAO,CAAC,UAAU;IAClB,QAAQ,CAAC,QAAQ,EAAE,GAAG;gBADd,UAAU,EAAE,UAAU,EACrB,QAAQ,EAAE,GAAG,EACtB,QAAQ,GAAE,MAAuC;IAK7C,IAAI,CACR,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;IA4B7B,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,YAAY,CAAC;IAsB1E,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,YAAY;CASlC"}

package/dist/client/server/server.manager.js

@@ -0,0 +1,39 @@
+import { ONE_MINUTE_IN_MILLISECONDS } from '../../utils/vars.js';
+import { BaseCacheManager } from '../../class/BaseCacheManager.js';
+import { buildQueryParams } from '../../utils/buildQueryParams.js';
+import { ClientServer } from './server.class.js';
+import { userServerFilterSchema } from '../client.schema.js';
+import { userServerId } from './server.schemas.js';
+export class ClientServerManager extends BaseCacheManager {
+    httpClient;
+    panelUrl;
+    constructor(httpClient, panelUrl, cacheTtl = ONE_MINUTE_IN_MILLISECONDS * 5) {
+        super(cacheTtl, 'id');
+        this.httpClient = httpClient;
+        this.panelUrl = panelUrl;
+    }
+    async list(options) {
+        const queries = buildQueryParams({
+            ...options,
+            filter: userServerFilterSchema.optional().parse(options?.filter),
+        });
+        const serverList = await this.httpClient.request('GET', `/client?${queries}`, { parseDates: true });
+        return {
+            data: serverList.data.map((serverObject) => this.setCache(new ClientServer(this.httpClient, this.panelUrl, this, serverObject.attributes), options?.cache)),
+            pagination: serverList.meta.pagination,
+        };
+    }
+    async fetch(id, options) {
+        const cacheServer = this.getCache(id);
+        if (cacheServer && !options?.force)
+            return cacheServer;
+        const parsedId = userServerId.parse(id);
+        const serverObject = await this.httpClient.request('GET', `/client/servers/${parsedId}`, { parseDates: true });
+        return this.setCache(new ClientServer(this.httpClient, this.panelUrl, this, serverObject.attributes), options?.cache);
+    }
+    resolve(id) {
+        return super.resolve(id, () => new ClientServer(this.httpClient, this.panelUrl, this, {
+            identifier: userServerId.parse(id),
+        }));
+    }
+}

package/dist/client/server/server.schemas.d.ts

@@ -1,97 +1,97 @@
-import z from 'zod';
-export declare const userServerId: z.ZodUnion<readonly [z.ZodString, z.ZodUUID]>;
-export declare const userServerSubuserId: z.ZodUUID;
-export declare const userServerDatabaseId: z.ZodString;
-export declare const userServerPort: z.ZodInt;
-export declare const userServerBackupId: z.ZodUUID;
-export declare const userServerScheduleId: z.ZodInt;
-export declare const userServerScheduleTaskId: z.ZodInt;
-export declare const allocationId: z.z.ZodCoercedNumber<number>;
-export declare const state: z.ZodLiteral<"running" | "starting" | "stopping" | "offline">;
-export declare const cronString: z.ZodString;
-export declare const userServerActivityEvent: z.ZodLiteral<"server:file.read" | "server:file.delete" | "server:database.create" | "server:database.delete" | "server:schedule.create" | "server:schedule.update" | "server:schedule.delete" | "server:allocation.create" | "server:allocation.delete" | "server:backup.delete" | "server:backup.download" | "server:backup.restore" | "server:control.console" | "server:control.start" | "server:control.stop" | "server:control.restart" | "server:control.kill" | "server:file.create" | "server:file.update" | "server:file.archive" | "server:file.sftp" | "server:backup.create" | "server:backup.read" | "server:allocation.read" | "server:allocation.update" | "server:database.read" | "server:database.update" | "server:schedule.read" | "server:user.read" | "server:user.create" | "server:user.update" | "server:user.delete" | "server:startup.read" | "server:startup.update" | "server:admin.websocket.errors" | "server:admin.websocket.install" | "server:admin.websocket.transfer">;
-export declare const assignAllocationSchema: z.ZodObject<{
-    ip: z.ZodIPv4;
-    port: z.ZodInt;
-}, z.z.core.$strip>;
-export declare const editAllocationSchema: z.ZodObject<{
-    notes: z.ZodOptional<z.ZodString>;
-}, z.z.core.$strip>;
-export declare const userServerCommandSchema: z.ZodObject<{
-    command: z.ZodString;
-}, z.z.core.$strip>;
-export declare const userServerWebsocketSchema: z.ZodObject<{
-    onConsoleOutput: z.ZodOptional<z.ZodFunction<z.ZodTuple<readonly [z.ZodString], null>, z.ZodUnion<readonly [z.ZodPromise<z.ZodVoid>, z.ZodVoid]>>>;
-    onStats: z.ZodOptional<z.ZodFunction<z.ZodTuple<readonly [z.ZodObject<{
-        cpu_absolute: z.ZodInt;
-        disk_bytes: z.ZodInt;
-        memory_bytes: z.ZodInt;
-        memory_limit_bytes: z.ZodInt;
-        network: z.ZodObject<{
-            rx_bytes: z.ZodInt;
-            tx_bytes: z.ZodInt;
-        }, z.z.core.$strip>;
-        state: z.ZodLiteral<"running" | "starting" | "stopping" | "offline">;
-        uptime: z.ZodInt;
-    }, z.z.core.$strip>], null>, z.ZodUnion<readonly [z.ZodPromise<z.ZodVoid>, z.ZodVoid]>>>;
-    onStatusChange: z.ZodOptional<z.ZodFunction<z.ZodTuple<readonly [z.ZodLiteral<"running" | "starting" | "stopping" | "offline">], null>, z.ZodUnion<readonly [z.ZodPromise<z.ZodVoid>, z.ZodVoid]>>>;
-}, z.z.core.$strip>;
-export declare const createBackupSchema: z.ZodObject<{
-    name: z.ZodOptional<z.ZodString>;
-    ignored: z.ZodOptional<z.ZodString>;
-    is_locked: z.ZodOptional<z.ZodBoolean>;
-}, z.z.core.$strip>;
-export declare const createScheduleSchema: z.ZodObject<{
-    name: z.ZodString;
-    minute: z.ZodString;
-    hour: z.ZodString;
-    day_of_month: z.ZodString;
-    month: z.ZodString;
-    day_of_week: z.ZodString;
-    is_active: z.ZodOptional<z.ZodBoolean>;
-    only_when_online: z.ZodOptional<z.ZodBoolean>;
-}, z.z.core.$strip>;
-export declare const createTaskSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    action: z.ZodLiteral<"command">;
-    payload: z.ZodString;
-    time_offset: z.ZodInt;
-    continue_on_failure: z.ZodOptional<z.ZodBoolean>;
-}, z.z.core.$strip>, z.ZodObject<{
-    action: z.ZodLiteral<"power">;
-    payload: z.ZodLiteral<"start" | "stop" | "restart" | "kill">;
-    time_offset: z.ZodInt;
-    continue_on_failure: z.ZodOptional<z.ZodBoolean>;
-}, z.z.core.$strip>, z.ZodObject<{
-    action: z.ZodLiteral<"backup">;
-    payload: z.ZodOptional<z.ZodString>;
-    time_offset: z.ZodInt;
-    continue_on_failure: z.ZodOptional<z.ZodBoolean>;
-}, z.z.core.$strip>], "action">;
-export declare const serverPermissionSchema: z.ZodLiteral<"control.console" | "control.start" | "control.stop" | "control.restart" | "control.kill" | "file.create" | "file.read" | "file.update" | "file.delete" | "file.archive" | "file.sftp" | "backup.create" | "backup.read" | "backup.delete" | "backup.download" | "backup.restore" | "allocation.read" | "allocation.create" | "allocation.update" | "allocation.delete" | "database.read" | "database.create" | "database.update" | "database.delete" | "schedule.read" | "schedule.create" | "schedule.update" | "schedule.delete" | "user.read" | "user.create" | "user.update" | "user.delete" | "startup.read" | "startup.update" | "admin.websocket.errors" | "admin.websocket.install" | "admin.websocket.transfer">;
-export declare const subuserPermissionSchema: z.ZodUnion<readonly [z.ZodLiteral<"control.console" | "control.start" | "control.stop" | "control.restart" | "control.kill" | "file.create" | "file.read" | "file.update" | "file.delete" | "file.archive" | "file.sftp" | "backup.create" | "backup.read" | "backup.delete" | "backup.download" | "backup.restore" | "allocation.read" | "allocation.create" | "allocation.update" | "allocation.delete" | "database.read" | "database.create" | "database.update" | "database.delete" | "schedule.read" | "schedule.create" | "schedule.update" | "schedule.delete" | "user.read" | "user.create" | "user.update" | "user.delete" | "startup.read" | "startup.update" | "admin.websocket.errors" | "admin.websocket.install" | "admin.websocket.transfer">, z.ZodLiteral<"*">]>;
-export declare const createSubuserSchema: z.ZodObject<{
-    email: z.ZodString;
-    permissions: z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<"control.console" | "control.start" | "control.stop" | "control.restart" | "control.kill" | "file.create" | "file.read" | "file.update" | "file.delete" | "file.archive" | "file.sftp" | "backup.create" | "backup.read" | "backup.delete" | "backup.download" | "backup.restore" | "allocation.read" | "allocation.create" | "allocation.update" | "allocation.delete" | "database.read" | "database.create" | "database.update" | "database.delete" | "schedule.read" | "schedule.create" | "schedule.update" | "schedule.delete" | "user.read" | "user.create" | "user.update" | "user.delete" | "startup.read" | "startup.update" | "admin.websocket.errors" | "admin.websocket.install" | "admin.websocket.transfer">, z.ZodLiteral<"*">]>>;
-}, z.z.core.$strip>;
-export declare const editSubuserSchema: z.ZodObject<{
-    permissions: z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<"control.console" | "control.start" | "control.stop" | "control.restart" | "control.kill" | "file.create" | "file.read" | "file.update" | "file.delete" | "file.archive" | "file.sftp" | "backup.create" | "backup.read" | "backup.delete" | "backup.download" | "backup.restore" | "allocation.read" | "allocation.create" | "allocation.update" | "allocation.delete" | "database.read" | "database.create" | "database.update" | "database.delete" | "schedule.read" | "schedule.create" | "schedule.update" | "schedule.delete" | "user.read" | "user.create" | "user.update" | "user.delete" | "startup.read" | "startup.update" | "admin.websocket.errors" | "admin.websocket.install" | "admin.websocket.transfer">, z.ZodLiteral<"*">]>>;
-}, z.z.core.$strip>;
-export declare const createDatabaseSchema: z.ZodObject<{
-    database: z.ZodString;
-    remote: z.ZodString;
-}, z.z.core.$strip>;
-export declare const restoreBackupSchema: z.ZodObject<{
-    truncate: z.ZodOptional<z.ZodBoolean>;
-}, z.z.core.$strip>;
-export declare const editVariableSchema: z.ZodObject<{
-    key: z.ZodString;
-    value: z.ZodString;
-}, z.z.core.$strip>;
-export declare const renameServerSchema: z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-}, z.z.core.$strip>;
-export declare const editImageSchema: z.ZodObject<{
-    docker_image: z.ZodString;
-}, z.z.core.$strip>;
+import { coerce } from 'zod';
+export declare const userServerId: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodUUID]>;
+export declare const userServerSubuserId: import("zod").ZodUUID;
+export declare const userServerDatabaseId: import("zod").ZodString;
+export declare const userServerPort: import("zod").ZodInt;
+export declare const userServerBackupId: import("zod").ZodUUID;
+export declare const userServerScheduleId: import("zod").ZodInt;
+export declare const userServerTaskId: import("zod").ZodInt;
+export declare const allocationId: coerce.ZodCoercedNumber<number>;
+export declare const state: import("zod").ZodLiteral<"running" | "starting" | "stopping" | "offline">;
+export declare const cronString: import("zod").ZodString;
+export declare const userServerActivityEvent: import("zod").ZodLiteral<"server:control.console" | "server:control.start" | "server:control.stop" | "server:control.restart" | "server:control.kill" | "server:file.create" | "server:file.read" | "server:file.update" | "server:file.delete" | "server:file.archive" | "server:file.sftp" | "server:backup.create" | "server:backup.read" | "server:backup.delete" | "server:backup.download" | "server:backup.restore" | "server:allocation.read" | "server:allocation.create" | "server:allocation.update" | "server:allocation.delete" | "server:database.read" | "server:database.create" | "server:database.update" | "server:schedule.read" | "server:schedule.create" | "server:schedule.update" | "server:schedule.delete" | "server:database.delete" | "server:user.read" | "server:user.create" | "server:user.update" | "server:user.delete" | "server:startup.read" | "server:startup.update" | "server:admin.websocket.errors" | "server:admin.websocket.install" | "server:admin.websocket.transfer">;
+export declare const assignAllocationSchema: import("zod").ZodObject<{
+    ip: import("zod").ZodIPv4;
+    port: import("zod").ZodInt;
+}, import("zod/v4/core").$strip>;
+export declare const updateAllocationSchema: import("zod").ZodObject<{
+    notes: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>;
+export declare const userServerCommandSchema: import("zod").ZodObject<{
+    command: import("zod").ZodString;
+}, import("zod/v4/core").$strip>;
+export declare const userServerWebsocketSchema: import("zod").ZodObject<{
+    onConsoleOutput: import("zod").ZodOptional<import("zod").ZodFunction<import("zod").ZodTuple<readonly [import("zod").ZodString], null>, import("zod").ZodUnion<readonly [import("zod").ZodPromise<import("zod").ZodVoid>, import("zod").ZodVoid]>>>;
+    onStats: import("zod").ZodOptional<import("zod").ZodFunction<import("zod").ZodTuple<readonly [import("zod").ZodObject<{
+        cpu_absolute: import("zod").ZodInt;
+        disk_bytes: import("zod").ZodInt;
+        memory_bytes: import("zod").ZodInt;
+        memory_limit_bytes: import("zod").ZodInt;
+        network: import("zod").ZodObject<{
+            rx_bytes: import("zod").ZodInt;
+            tx_bytes: import("zod").ZodInt;
+        }, import("zod/v4/core").$strip>;
+        state: import("zod").ZodLiteral<"running" | "starting" | "stopping" | "offline">;
+        uptime: import("zod").ZodInt;
+    }, import("zod/v4/core").$strip>], null>, import("zod").ZodUnion<readonly [import("zod").ZodPromise<import("zod").ZodVoid>, import("zod").ZodVoid]>>>;
+    onStatusChange: import("zod").ZodOptional<import("zod").ZodFunction<import("zod").ZodTuple<readonly [import("zod").ZodLiteral<"running" | "starting" | "stopping" | "offline">], null>, import("zod").ZodUnion<readonly [import("zod").ZodPromise<import("zod").ZodVoid>, import("zod").ZodVoid]>>>;
+}, import("zod/v4/core").$strip>;
+export declare const createBackupSchema: import("zod").ZodObject<{
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    ignored: import("zod").ZodOptional<import("zod").ZodString>;
+    is_locked: import("zod").ZodOptional<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>;
+export declare const createScheduleSchema: import("zod").ZodObject<{
+    name: import("zod").ZodString;
+    minute: import("zod").ZodString;
+    hour: import("zod").ZodString;
+    day_of_month: import("zod").ZodString;
+    month: import("zod").ZodString;
+    day_of_week: import("zod").ZodString;
+    is_active: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    only_when_online: import("zod").ZodOptional<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>;
+export declare const createTaskSchema: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+    action: import("zod").ZodLiteral<"command">;
+    payload: import("zod").ZodString;
+    time_offset: import("zod").ZodInt;
+    continue_on_failure: import("zod").ZodOptional<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    action: import("zod").ZodLiteral<"power">;
+    payload: import("zod").ZodLiteral<"stop" | "start" | "restart" | "kill">;
+    time_offset: import("zod").ZodInt;
+    continue_on_failure: import("zod").ZodOptional<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    action: import("zod").ZodLiteral<"backup">;
+    payload: import("zod").ZodOptional<import("zod").ZodString>;
+    time_offset: import("zod").ZodInt;
+    continue_on_failure: import("zod").ZodOptional<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>], "action">;
+export declare const serverPermissionSchema: import("zod").ZodLiteral<"control.console" | "control.start" | "control.stop" | "control.restart" | "control.kill" | "file.create" | "file.read" | "file.update" | "file.delete" | "file.archive" | "file.sftp" | "backup.create" | "backup.read" | "backup.delete" | "backup.download" | "backup.restore" | "allocation.read" | "allocation.create" | "allocation.update" | "allocation.delete" | "database.read" | "database.create" | "database.update" | "database.delete" | "schedule.read" | "schedule.create" | "schedule.update" | "schedule.delete" | "user.read" | "user.create" | "user.update" | "user.delete" | "startup.read" | "startup.update" | "admin.websocket.errors" | "admin.websocket.install" | "admin.websocket.transfer">;
+export declare const subuserPermissionSchema: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"control.console" | "control.start" | "control.stop" | "control.restart" | "control.kill" | "file.create" | "file.read" | "file.update" | "file.delete" | "file.archive" | "file.sftp" | "backup.create" | "backup.read" | "backup.delete" | "backup.download" | "backup.restore" | "allocation.read" | "allocation.create" | "allocation.update" | "allocation.delete" | "database.read" | "database.create" | "database.update" | "database.delete" | "schedule.read" | "schedule.create" | "schedule.update" | "schedule.delete" | "user.read" | "user.create" | "user.update" | "user.delete" | "startup.read" | "startup.update" | "admin.websocket.errors" | "admin.websocket.install" | "admin.websocket.transfer">, import("zod").ZodLiteral<"*">]>;
+export declare const createSubuserSchema: import("zod").ZodObject<{
+    email: import("zod").ZodString;
+    permissions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"control.console" | "control.start" | "control.stop" | "control.restart" | "control.kill" | "file.create" | "file.read" | "file.update" | "file.delete" | "file.archive" | "file.sftp" | "backup.create" | "backup.read" | "backup.delete" | "backup.download" | "backup.restore" | "allocation.read" | "allocation.create" | "allocation.update" | "allocation.delete" | "database.read" | "database.create" | "database.update" | "database.delete" | "schedule.read" | "schedule.create" | "schedule.update" | "schedule.delete" | "user.read" | "user.create" | "user.update" | "user.delete" | "startup.read" | "startup.update" | "admin.websocket.errors" | "admin.websocket.install" | "admin.websocket.transfer">, import("zod").ZodLiteral<"*">]>>;
+}, import("zod/v4/core").$strip>;
+export declare const setSubuserPermissionsSchema: import("zod").ZodObject<{
+    permissions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"control.console" | "control.start" | "control.stop" | "control.restart" | "control.kill" | "file.create" | "file.read" | "file.update" | "file.delete" | "file.archive" | "file.sftp" | "backup.create" | "backup.read" | "backup.delete" | "backup.download" | "backup.restore" | "allocation.read" | "allocation.create" | "allocation.update" | "allocation.delete" | "database.read" | "database.create" | "database.update" | "database.delete" | "schedule.read" | "schedule.create" | "schedule.update" | "schedule.delete" | "user.read" | "user.create" | "user.update" | "user.delete" | "startup.read" | "startup.update" | "admin.websocket.errors" | "admin.websocket.install" | "admin.websocket.transfer">, import("zod").ZodLiteral<"*">]>>;
+}, import("zod/v4/core").$strip>;
+export declare const createDatabaseSchema: import("zod").ZodObject<{
+    database: import("zod").ZodString;
+    remote: import("zod").ZodString;
+}, import("zod/v4/core").$strip>;
+export declare const restoreBackupSchema: import("zod").ZodObject<{
+    truncate: import("zod").ZodOptional<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>;
+export declare const setEnvironmentVariableSchema: import("zod").ZodObject<{
+    key: import("zod").ZodString;
+    value: import("zod").ZodString;
+}, import("zod/v4/core").$strip>;
+export declare const setUserServerDetailsSchema: import("zod").ZodObject<{
+    name: import("zod").ZodString;
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>;
+export declare const setImageSchema: import("zod").ZodObject<{
+    docker_image: import("zod").ZodString;
+}, import("zod/v4/core").$strip>;
 //# sourceMappingURL=server.schemas.d.ts.map

package/dist/client/server/server.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.schemas.d.ts","sourceRoot":"","sources":["../../../src/client/server/server.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAGpB,eAAO,MAAM,YAAY,+CAA8C,CAAC;AACxE,eAAO,MAAM,mBAAmB,WAAa,CAAC;AAC9C,eAAO,MAAM,oBAAoB,aAAuB,CAAC;AACzD,eAAO,MAAM,cAAc,UAA0C,CAAC;AACtE,eAAO,MAAM,kBAAkB,WAAa,CAAC;AAC7C,eAAO,MAAM,oBAAoB,UAAqB,CAAC;AACvD,eAAO,MAAM,wBAAwB,UAAqB,CAAC;AAC3D,eAAO,MAAM,YAAY,8BAA4B,CAAC;AACtD,eAAO,MAAM,KAAK,+DAA4D,CAAC;AAC/E,eAAO,MAAM,UAAU,aAA2C,CAAC;AAEnE,eAAO,MAAM,uBAAuB,48BAsClC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;mBAGjC,CAAC;AAEH,eAAO,MAAM,oBAAoB;;mBAE/B,CAAC;AAEH,eAAO,MAAM,uBAAuB;;mBAElC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;mBAgCpC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;mBAI7B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;mBAS/B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;+BAmB3B,CAAC;AAEH,eAAO,MAAM,sBAAsB,ysBAsCjC,CAAC;AAEH,eAAO,MAAM,uBAAuB,mvBAGlC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;mBAG9B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;mBAE5B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;mBAG/B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;mBAE9B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;mBAG7B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;mBAG7B,CAAC;AAEH,eAAO,MAAM,eAAe;;mBAK1B,CAAC"}
+{"version":3,"file":"server.schemas.d.ts","sourceRoot":"","sources":["../../../src/client/server/server.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,MAAM,EAWP,MAAM,KAAK,CAAC;AAGb,eAAO,MAAM,YAAY,mFAA0C,CAAC;AACpE,eAAO,MAAM,mBAAmB,uBAAa,CAAC;AAC9C,eAAO,MAAM,oBAAoB,yBAAqB,CAAC;AACvD,eAAO,MAAM,cAAc,sBAAwC,CAAC;AACpE,eAAO,MAAM,kBAAkB,uBAAa,CAAC;AAC7C,eAAO,MAAM,oBAAoB,sBAAmB,CAAC;AACrD,eAAO,MAAM,gBAAgB,sBAAmB,CAAC;AACjD,eAAO,MAAM,YAAY,iCAA0B,CAAC;AACpD,eAAO,MAAM,KAAK,2EAA0D,CAAC;AAC7E,eAAO,MAAM,UAAU,yBAAyC,CAAC;AAEjE,eAAO,MAAM,uBAAuB,w9BAsClC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;gCAGjC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;gCAEjC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;gCAElC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;gCA0BpC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;gCAI7B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;gCAS/B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;4CAmB3B,CAAC;AAEH,eAAO,MAAM,sBAAsB,qtBAsCjC,CAAC;AAEH,eAAO,MAAM,uBAAuB,uxBAGlC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;gCAG9B,CAAC;AAEH,eAAO,MAAM,2BAA2B;;gCAEtC,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;gCAG/B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;gCAE9B,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;gCAGvC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;gCAGrC,CAAC;AAEH,eAAO,MAAM,cAAc;;gCAIzB,CAAC"}

package/dist/client/server/server.schemas.js

@@ -1,16 +1,16 @@
-import z from 'zod';
+import { boolean, coerce, discriminatedUnion, int, ipv4, literal, object, promise, string, union, void as zVoid, function as zFunction, } from 'zod';
 import { uuidSchema } from '../../schemas.js';
-export const userServerId = z.union([z.string().length(8), uuidSchema]);
+export const userServerId = union([string().length(8), uuidSchema]);
 export const userServerSubuserId = uuidSchema;
-export const userServerDatabaseId = z.string().length(8);
-export const userServerPort = z.int().positive().min(1024).max(65535);
+export const userServerDatabaseId = string().length(8);
+export const userServerPort = int().positive().min(1024).max(65535);
 export const userServerBackupId = uuidSchema;
-export const userServerScheduleId = z.int().positive();
-export const userServerScheduleTaskId = z.int().positive();
-export const allocationId = z.coerce.number();
-export const state = z.literal(['running', 'starting', 'stopping', 'offline']);
-export const cronString = z.string().regex(/^(?:\*|\d+|\*\/\d+)$/);
-export const userServerActivityEvent = z.literal([
+export const userServerScheduleId = int().positive();
+export const userServerTaskId = int().positive();
+export const allocationId = coerce.number();
+export const state = literal(['running', 'starting', 'stopping', 'offline']);
+export const cronString = string().regex(/^(?:\*|\d+|\*\/\d+)$/);
+export const userServerActivityEvent = literal([
     'server:control.console',
     'server:control.start',
     'server:control.stop',
@@ -49,85 +49,79 @@ export const userServerActivityEvent = z.literal([
     'server:admin.websocket.install',
     'server:admin.websocket.transfer',
 ]);
-export const assignAllocationSchema = z.object({
-    ip: z.ipv4(),
+export const assignAllocationSchema = object({
+    ip: ipv4(),
     port: userServerPort,
 });
-export const editAllocationSchema = z.object({
-    notes: z.string().min(1).max(255).optional(),
+export const updateAllocationSchema = object({
+    notes: string().min(1).max(255).optional(),
 });
-export const userServerCommandSchema = z.object({
-    command: z.string(),
+export const userServerCommandSchema = object({
+    command: string(),
 });
-export const userServerWebsocketSchema = z.object({
-    onConsoleOutput: z
-        .function({
-        input: [z.string()],
-        output: z.union([z.promise(z.void()), z.void()]),
-    })
-        .optional(),
-    onStats: z
-        .function({
+export const userServerWebsocketSchema = object({
+    onConsoleOutput: zFunction({
+        input: [string()],
+        output: union([promise(zVoid()), zVoid()]),
+    }).optional(),
+    onStats: zFunction({
         input: [
-            z.object({
-                cpu_absolute: z.int().positive(),
-                disk_bytes: z.int().positive(),
-                memory_bytes: z.int().positive(),
-                memory_limit_bytes: z.int().positive(),
-                network: z.object({
-                    rx_bytes: z.int().positive(),
-                    tx_bytes: z.int().positive(),
+            object({
+                cpu_absolute: int().positive(),
+                disk_bytes: int().positive(),
+                memory_bytes: int().positive(),
+                memory_limit_bytes: int().positive(),
+                network: object({
+                    rx_bytes: int().positive(),
+                    tx_bytes: int().positive(),
                 }),
                 state: state,
-                uptime: z.int().positive(),
+                uptime: int().positive(),
             }),
         ],
-        output: z.union([z.promise(z.void()), z.void()]),
-    })
-        .optional(),
-    onStatusChange: z
-        .function({
+        output: union([promise(zVoid()), zVoid()]),
+    }).optional(),
+    onStatusChange: zFunction({
         input: [state],
-        output: z.union([z.promise(z.void()), z.void()]),
-    })
-        .optional(),
+        output: union([promise(zVoid()), zVoid()]),
+    }).optional(),
 });
-export const createBackupSchema = z.object({
-    name: z.string().max(195).optional(),
-    ignored: z.string().optional(),
-    is_locked: z.boolean().optional(),
+export const createBackupSchema = object({
+    name: string().max(195).optional(),
+    ignored: string().optional(),
+    is_locked: boolean().optional(),
 });
-export const createScheduleSchema = z.object({
-    name: z.string(),
+export const createScheduleSchema = object({
+    name: string(),
     minute: cronString,
     hour: cronString,
     day_of_month: cronString,
     month: cronString,
     day_of_week: cronString,
-    is_active: z.boolean().optional(),
-    only_when_online: z.boolean().optional(),
+    is_active: boolean().optional(),
+    only_when_online: boolean().optional(),
 });
-export const createTaskSchema = z.discriminatedUnion('action', [
-    z.object({
-        action: z.literal('command'),
-        payload: z.string(),
-        time_offset: z.int().min(0).max(900),
-        continue_on_failure: z.boolean().optional(),
+export const createTaskSchema = discriminatedUnion('action', [
+    object({
+        action: literal('command'),
+        payload: string(),
+        time_offset: int().min(0).max(900),
+        continue_on_failure: boolean().optional(),
     }),
-    z.object({
-        action: z.literal('power'),
-        payload: z.literal(['start', 'stop', 'restart', 'kill']),
-        time_offset: z.int().min(0).max(900),
-        continue_on_failure: z.boolean().optional(),
+    object({
+        action: literal('power'),
+        payload: literal(['start', 'stop', 'restart', 'kill']),
+        time_offset: int().min(0).max(900),
+        continue_on_failure: boolean().optional(),
     }),
-    z.object({
-        action: z.literal('backup'),
-        payload: z.string().optional(),
-        time_offset: z.int().min(0).max(900),
-        continue_on_failure: z.boolean().optional(),
+    object({
+        action: literal('backup'),
+        payload: string().optional(),
+        time_offset: int().min(0).max(900),
+        continue_on_failure: boolean().optional(),
     }),
 ]);
-export const serverPermissionSchema = z.literal([
+export const serverPermissionSchema = literal([
     'control.console',
     'control.start',
     'control.stop',
@@ -166,35 +160,34 @@ export const serverPermissionSchema = z.literal([
     'admin.websocket.install',
     'admin.websocket.transfer',
 ]);
-export const subuserPermissionSchema = z.union([
+export const subuserPermissionSchema = union([
     serverPermissionSchema,
-    z.literal('*'),
+    literal('*'),
 ]);
-export const createSubuserSchema = z.object({
-    email: z.string().email().min(1).max(191),
+export const createSubuserSchema = object({
+    email: string().email().min(1).max(191),
     permissions: subuserPermissionSchema.array(),
 });
-export const editSubuserSchema = z.object({
+export const setSubuserPermissionsSchema = object({
     permissions: subuserPermissionSchema.array(),
 });
-export const createDatabaseSchema = z.object({
-    database: z.string().min(1).max(48),
-    remote: z.string(),
+export const createDatabaseSchema = object({
+    database: string().min(1).max(48),
+    remote: string(),
 });
-export const restoreBackupSchema = z.object({
-    truncate: z.boolean().optional(),
+export const restoreBackupSchema = object({
+    truncate: boolean().optional(),
 });
-export const editVariableSchema = z.object({
-    key: z.string(),
-    value: z.string(),
+export const setEnvironmentVariableSchema = object({
+    key: string().uppercase(),
+    value: string(),
 });
-export const renameServerSchema = z.object({
-    name: z.string().min(1).max(255),
-    description: z.string().max(500).optional(),
+export const setUserServerDetailsSchema = object({
+    name: string().min(1).max(255),
+    description: string().max(500).optional(),
 });
-export const editImageSchema = z.object({
-    docker_image: z
-        .string()
+export const setImageSchema = object({
+    docker_image: string()
         .max(191)
         .regex(/^[\w#\.\/\- ]*\|?~?[\w\.\/\-:@ ]*$/),
 });