pterodactyl-api-client 3.4.1 → 4.0.0

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

@@ -1 +1 @@
-{"version":3,"file":"server.client.d.ts","sourceRoot":"","sources":["../../../src/client/server/server.client.ts"],"names":[],"mappings":"AACA,OAAO,UAAU,MAAM,2BAA2B,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAEzD,OAAO,gBAAgB,MAAM,mCAAmC,CAAC;AACjE,OAAO,iBAAiB,MAAM,qCAAqC,CAAC;AACpE,OAAO,YAAY,MAAM,2BAA2B,CAAC;AACrD,OAAO,aAAa,MAAM,6BAA6B,CAAC;AACxD,OAAO,aAAa,MAAM,6BAA6B,CAAC;AACxD,OAAO,cAAc,MAAM,+BAA+B,CAAC;AAC3D,OAAO,eAAe,MAAM,iCAAiC,CAAC;AAC9D,OAAO,WAAW,MAAM,yBAAyB,CAAC;AAClD,OAAO,WAAW,MAAM,yBAAyB,CAAC;AAClD,OAAO,eAAe,MAAM,iCAAiC,CAAC;AAC9D,OAAO,cAAc,MAAM,+BAA+B,CAAC;AAC3D,OAAO,eAAe,MAAM,iCAAiC,CAAC;AAM9D,OAAO,KAAK,EACV,cAAc,EACd,WAAW,EACX,kBAAkB,EAClB,qBAAqB,EACtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,aAAa,MAAM,6BAA6B,CAAC;AACxD,OAAO,aAAa,MAAM,6BAA6B,CAAC;AACxD,OAAO,cAAc,MAAM,+BAA+B,CAAC;AAE3D,MAAM,CAAC,OAAO,OAAO,OAAO;IAexB,OAAO,CAAC,UAAU;IAClB,QAAQ,CAAC,QAAQ,EAAE,GAAG;IAfjB,WAAW,EAAE,iBAAiB,CAAC;IAC/B,OAAO,EAAE,aAAa,CAAC;IACvB,OAAO,EAAE,aAAa,CAAC;IACvB,SAAS,EAAE,eAAe,CAAC;IAC3B,KAAK,EAAE,WAAW,CAAC;IACnB,KAAK,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,eAAe,CAAC;IAC3B,SAAS,EAAE,eAAe,CAAC;IAC3B,OAAO,EAAE,aAAa,CAAC;IACvB,QAAQ,EAAE,cAAc,CAAC;IAEhC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;gBAGV,UAAU,EAAE,UAAU,EACrB,QAAQ,EAAE,GAAG,EACtB,EAAE,EAAE,MAAM;IAgBN,QAAQ,CAAC,CAAC,SAAS,WAAW,EAAE,EACpC,IAAI,EACJ,QAAQ,EACR,MAAM,EACN,IAAI,GACL,GACG,CAAC,YAAY,GAAG;QACd,MAAM,CAAC,EACH;YACE,KAAK,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;SACvB,GACD,SAAS,CAAC;QACd,IAAI,CAAC,EACD;YACE,SAAS,CAAC,EAAE,IAAI,GAAG,SAAS,CAAC;SAC9B,GACD,SAAS,CAAC;KACf,CAAC,GACF,SAAc,GAAG,OAAO,CAAC,kBAAkB,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IA+BzD,UAAU,CAAC,UAAU,EAAE,MAAM;IAI7B,MAAM,CAAC,MAAM,EAAE,MAAM;IAIrB,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAIzB,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAIzB,OAAO,CAAC,OAAO,EAAE,MAAM;IAIvB,IAAI;IAOJ,IAAI,CAAC,OAAO,EAAE,cAAc;IAQ5B,SAAS;CAMV"}
+{"version":3,"file":"server.client.d.ts","sourceRoot":"","sources":["../../../src/client/server/server.client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,KAAK,EAA4B,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE1E,OAAO,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAMlE,OAAO,KAAK,EACV,2BAA2B,EAC3B,WAAW,EAEX,kCAAkC,EAElC,WAAW,EACZ,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,qBAAa,gBAAgB;IAezB,OAAO,CAAC,UAAU;IAClB,QAAQ,CAAC,QAAQ,EAAE,GAAG;IAfjB,WAAW,EAAE,iBAAiB,CAAC;IAC/B,OAAO,EAAE,aAAa,CAAC;IACvB,OAAO,EAAE,aAAa,CAAC;IACvB,SAAS,EAAE,eAAe,CAAC;IAC3B,KAAK,EAAE,WAAW,CAAC;IACnB,KAAK,EAAE,WAAW,CAAC;IACnB,QAAQ,EAAE,cAAc,CAAC;IACzB,SAAS,EAAE,eAAe,CAAC;IAC3B,OAAO,EAAE,aAAa,CAAC;IACvB,QAAQ,EAAE,cAAc,CAAC;IAEhC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;gBAGV,UAAU,EAAE,UAAU,EACrB,QAAQ,EAAE,GAAG,EACtB,EAAE,EAAE,MAAM;IAgBN,iBAAiB,CAAC,KAAK,SAAS,WAAW,EAC/C,OAAO,CAAC,EAAE,kCAAkC,CAAC,KAAK,CAAC,GAClD,OAAO,CAAC,SAAS,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;IAqBzC,UAAU,CAAC,UAAU,EAAE,MAAM;IAI7B,MAAM,CAAC,MAAM,EAAE,MAAM;IAIrB,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAIzB,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAIzB,OAAO,CAAC,OAAO,EAAE,MAAM;IAIvB,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAQL,UAAU,CAAC,OAAO,EAAE,2BAA2B;IAQ/C,SAAS;CAMV"}

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

@@ -1,22 +1,22 @@
-import HttpClient from '../../class/HttpClient.js';
-import buildQueryParams from '../../utils/buildQueryParams.js';
-import AllocationClient from './allocation/allocation.client.js';
-import AllocationsClient from './allocations/allocations.client.js';
-import BackupClient from './backup/backup.client.js';
-import BackupsClient from './backups/backups.client.js';
-import ConsoleClient from './console/console.client.js';
-import DatabaseClient from './database/database.client.js';
-import DatabasesClient from './databases/databases.client.js';
-import ImageClient from './image/image.client.js';
-import PowerClient from './power/power.client.js';
-import RessourceClient from './ressource/ressource.client.js';
-import ScheduleClient from './schedule/schedule.client.js';
-import SchedulesClient from './schedules/schedules.client.js';
-import { renameServerSchema, userServerActivityEvent, userServerId, } from './server.schemas.js';
-import StartupClient from './startup/startup.client.js';
-import SubuserClient from './subuser/subuser.client.js';
-import SubusersClient from './subusers/subusers.client.js';
-export default class Servers {
+import { HttpClient } from '../../class/HttpClient.js';
+import { buildQueryParams } from '../../utils/buildQueryParams.js';
+import { AllocationClient } from './allocation/allocation.client.js';
+import { AllocationsClient } from './allocations/allocations.client.js';
+import { BackupClient } from './backup/backup.client.js';
+import { BackupsClient } from './backups/backups.client.js';
+import { ConsoleClient } from './console/console.client.js';
+import { DatabaseClient } from './database/database.client.js';
+import { DatabasesClient } from './databases/databases.client.js';
+import { ImageClient } from './image/image.client.js';
+import { PowerClient } from './power/power.client.js';
+import { ResourceClient } from './resource/resource.client.js';
+import { ScheduleClient } from './schedule/schedule.client.js';
+import { SchedulesClient } from './schedules/schedules.client.js';
+import { setUserServerDetailsSchema, userServerActivityEvent, userServerId, } from './server.schemas.js';
+import { StartupClient } from './startup/startup.client.js';
+import { SubuserClient } from './subuser/subuser.client.js';
+import { SubusersClient } from './subusers/subusers.client.js';
+export class UserServerClient {
     httpClient;
     panelUrl;
     allocations;
@@ -25,7 +25,7 @@ export default class Servers {
     databases;
     image;
     power;
-    ressource;
+    resource;
     schedules;
     startup;
     subusers;
@@ -40,29 +40,25 @@ export default class Servers {
         this.databases = new DatabasesClient(httpClient, this.id);
         this.image = new ImageClient(httpClient, this.id);
         this.power = new PowerClient(httpClient, this.id);
-        this.ressource = new RessourceClient(httpClient, this.id);
+        this.resource = new ResourceClient(httpClient, this.id);
         this.schedules = new SchedulesClient(httpClient, this.id);
         this.startup = new StartupClient(httpClient, this.id);
         this.subusers = new SubusersClient(httpClient, this.id);
     }
-    async activity({ page, per_page, filter, sort, } = {}) {
-        const event = userServerActivityEvent.optional().parse(filter?.event);
+    async fetchActivityLogs(options) {
+        const event = userServerActivityEvent
+            .optional()
+            .parse(options?.filter?.event);
         const queries = buildQueryParams({
-            page,
-            per_page,
+            ...options,
             filter: { event },
-            sort,
         });
-        const res = await this.httpClient.request('GET', `/client/servers/${this.id}/activity?${queries}`);
+        const activityObjectList = await this.httpClient.request('GET', `/client/servers/${this.id}/activity?${queries}`, {
+            parseDates: true,
+        });
         return {
-            ...res,
-            data: res.data.map((data) => ({
-                ...data,
-                attributes: {
-                    ...data.attributes,
-                    timestamp: new Date(data.attributes.timestamp),
-                },
-            })),
+            data: activityObjectList.data.map((activityObject) => activityObject.attributes),
+            pagination: activityObjectList.meta.pagination,
         };
     }
     allocation(allocation) {
@@ -80,11 +76,11 @@ export default class Servers {
     subuser(subuser) {
         return new SubuserClient(this.httpClient, this.id, subuser);
     }
-    info() {
-        return this.httpClient.request('GET', `/client/servers/${this.id}`);
+    fetch() {
+        return this.httpClient.request('GET', `/client/servers/${this.id}`, { parseDates: true });
     }
-    edit(options) {
-        return this.httpClient.request('POST', `/client/servers/${this.id}/settings/rename`, renameServerSchema.parse(options));
+    setDetails(payload) {
+        return this.httpClient.request('POST', `/client/servers/${this.id}/settings/rename`, setUserServerDetailsSchema.parse(payload));
     }
     reinstall() {
         return this.httpClient.request('POST', `/client/servers/${this.id}/settings/reinstall`);

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\.\/\-:@ ]*$/),
 });