latitudesh-typescript-sdk 0.4.1 → 0.6.0

package/src/models/operations/createvirtualmachinenetworkattachment.ts

@@ -0,0 +1,196 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import * as models from "../index.js";
+
+export type CreateVirtualMachineNetworkAttachmentRequest = {
+  virtualMachineId: string;
+  virtualMachineNetworkAttachmentCreatePayload:
+    models.VirtualMachineNetworkAttachmentCreatePayload;
+};
+
+export type CreateVirtualMachineNetworkAttachmentMeta = {
+  status?: string | undefined;
+};
+
+/**
+ * Accepted
+ */
+export type CreateVirtualMachineNetworkAttachmentResponse = {
+  meta?: CreateVirtualMachineNetworkAttachmentMeta | undefined;
+};
+
+/** @internal */
+export const CreateVirtualMachineNetworkAttachmentRequest$inboundSchema:
+  z.ZodType<
+    CreateVirtualMachineNetworkAttachmentRequest,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    virtual_machine_id: z.string(),
+    virtual_machine_network_attachment_create_payload:
+      models.VirtualMachineNetworkAttachmentCreatePayload$inboundSchema,
+  }).transform((v) => {
+    return remap$(v, {
+      "virtual_machine_id": "virtualMachineId",
+      "virtual_machine_network_attachment_create_payload":
+        "virtualMachineNetworkAttachmentCreatePayload",
+    });
+  });
+/** @internal */
+export type CreateVirtualMachineNetworkAttachmentRequest$Outbound = {
+  virtual_machine_id: string;
+  virtual_machine_network_attachment_create_payload:
+    models.VirtualMachineNetworkAttachmentCreatePayload$Outbound;
+};
+
+/** @internal */
+export const CreateVirtualMachineNetworkAttachmentRequest$outboundSchema:
+  z.ZodType<
+    CreateVirtualMachineNetworkAttachmentRequest$Outbound,
+    z.ZodTypeDef,
+    CreateVirtualMachineNetworkAttachmentRequest
+  > = z.object({
+    virtualMachineId: z.string(),
+    virtualMachineNetworkAttachmentCreatePayload:
+      models.VirtualMachineNetworkAttachmentCreatePayload$outboundSchema,
+  }).transform((v) => {
+    return remap$(v, {
+      virtualMachineId: "virtual_machine_id",
+      virtualMachineNetworkAttachmentCreatePayload:
+        "virtual_machine_network_attachment_create_payload",
+    });
+  });
+
+export function createVirtualMachineNetworkAttachmentRequestToJSON(
+  createVirtualMachineNetworkAttachmentRequest:
+    CreateVirtualMachineNetworkAttachmentRequest,
+): string {
+  return JSON.stringify(
+    CreateVirtualMachineNetworkAttachmentRequest$outboundSchema.parse(
+      createVirtualMachineNetworkAttachmentRequest,
+    ),
+  );
+}
+export function createVirtualMachineNetworkAttachmentRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  CreateVirtualMachineNetworkAttachmentRequest,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateVirtualMachineNetworkAttachmentRequest$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'CreateVirtualMachineNetworkAttachmentRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateVirtualMachineNetworkAttachmentMeta$inboundSchema: z.ZodType<
+  CreateVirtualMachineNetworkAttachmentMeta,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  status: z.string().optional(),
+});
+/** @internal */
+export type CreateVirtualMachineNetworkAttachmentMeta$Outbound = {
+  status?: string | undefined;
+};
+
+/** @internal */
+export const CreateVirtualMachineNetworkAttachmentMeta$outboundSchema:
+  z.ZodType<
+    CreateVirtualMachineNetworkAttachmentMeta$Outbound,
+    z.ZodTypeDef,
+    CreateVirtualMachineNetworkAttachmentMeta
+  > = z.object({
+    status: z.string().optional(),
+  });
+
+export function createVirtualMachineNetworkAttachmentMetaToJSON(
+  createVirtualMachineNetworkAttachmentMeta:
+    CreateVirtualMachineNetworkAttachmentMeta,
+): string {
+  return JSON.stringify(
+    CreateVirtualMachineNetworkAttachmentMeta$outboundSchema.parse(
+      createVirtualMachineNetworkAttachmentMeta,
+    ),
+  );
+}
+export function createVirtualMachineNetworkAttachmentMetaFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  CreateVirtualMachineNetworkAttachmentMeta,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateVirtualMachineNetworkAttachmentMeta$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'CreateVirtualMachineNetworkAttachmentMeta' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateVirtualMachineNetworkAttachmentResponse$inboundSchema:
+  z.ZodType<
+    CreateVirtualMachineNetworkAttachmentResponse,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    meta: z.lazy(() => CreateVirtualMachineNetworkAttachmentMeta$inboundSchema)
+      .optional(),
+  });
+/** @internal */
+export type CreateVirtualMachineNetworkAttachmentResponse$Outbound = {
+  meta?: CreateVirtualMachineNetworkAttachmentMeta$Outbound | undefined;
+};
+
+/** @internal */
+export const CreateVirtualMachineNetworkAttachmentResponse$outboundSchema:
+  z.ZodType<
+    CreateVirtualMachineNetworkAttachmentResponse$Outbound,
+    z.ZodTypeDef,
+    CreateVirtualMachineNetworkAttachmentResponse
+  > = z.object({
+    meta: z.lazy(() => CreateVirtualMachineNetworkAttachmentMeta$outboundSchema)
+      .optional(),
+  });
+
+export function createVirtualMachineNetworkAttachmentResponseToJSON(
+  createVirtualMachineNetworkAttachmentResponse:
+    CreateVirtualMachineNetworkAttachmentResponse,
+): string {
+  return JSON.stringify(
+    CreateVirtualMachineNetworkAttachmentResponse$outboundSchema.parse(
+      createVirtualMachineNetworkAttachmentResponse,
+    ),
+  );
+}
+export function createVirtualMachineNetworkAttachmentResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  CreateVirtualMachineNetworkAttachmentResponse,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateVirtualMachineNetworkAttachmentResponse$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'CreateVirtualMachineNetworkAttachmentResponse' from JSON`,
+  );
+}

package/src/models/operations/destroyvirtualmachinenetworkattachment.ts

@@ -0,0 +1,189 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type DestroyVirtualMachineNetworkAttachmentRequest = {
+  virtualMachineId: string;
+  /**
+   * The VLAN id_hash to detach
+   */
+  id: string;
+};
+
+export type DestroyVirtualMachineNetworkAttachmentMeta = {
+  status?: string | undefined;
+};
+
+/**
+ * Accepted
+ */
+export type DestroyVirtualMachineNetworkAttachmentResponse = {
+  meta?: DestroyVirtualMachineNetworkAttachmentMeta | undefined;
+};
+
+/** @internal */
+export const DestroyVirtualMachineNetworkAttachmentRequest$inboundSchema:
+  z.ZodType<
+    DestroyVirtualMachineNetworkAttachmentRequest,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    virtual_machine_id: z.string(),
+    id: z.string(),
+  }).transform((v) => {
+    return remap$(v, {
+      "virtual_machine_id": "virtualMachineId",
+    });
+  });
+/** @internal */
+export type DestroyVirtualMachineNetworkAttachmentRequest$Outbound = {
+  virtual_machine_id: string;
+  id: string;
+};
+
+/** @internal */
+export const DestroyVirtualMachineNetworkAttachmentRequest$outboundSchema:
+  z.ZodType<
+    DestroyVirtualMachineNetworkAttachmentRequest$Outbound,
+    z.ZodTypeDef,
+    DestroyVirtualMachineNetworkAttachmentRequest
+  > = z.object({
+    virtualMachineId: z.string(),
+    id: z.string(),
+  }).transform((v) => {
+    return remap$(v, {
+      virtualMachineId: "virtual_machine_id",
+    });
+  });
+
+export function destroyVirtualMachineNetworkAttachmentRequestToJSON(
+  destroyVirtualMachineNetworkAttachmentRequest:
+    DestroyVirtualMachineNetworkAttachmentRequest,
+): string {
+  return JSON.stringify(
+    DestroyVirtualMachineNetworkAttachmentRequest$outboundSchema.parse(
+      destroyVirtualMachineNetworkAttachmentRequest,
+    ),
+  );
+}
+export function destroyVirtualMachineNetworkAttachmentRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  DestroyVirtualMachineNetworkAttachmentRequest,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DestroyVirtualMachineNetworkAttachmentRequest$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'DestroyVirtualMachineNetworkAttachmentRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const DestroyVirtualMachineNetworkAttachmentMeta$inboundSchema:
+  z.ZodType<DestroyVirtualMachineNetworkAttachmentMeta, z.ZodTypeDef, unknown> =
+    z.object({
+      status: z.string().optional(),
+    });
+/** @internal */
+export type DestroyVirtualMachineNetworkAttachmentMeta$Outbound = {
+  status?: string | undefined;
+};
+
+/** @internal */
+export const DestroyVirtualMachineNetworkAttachmentMeta$outboundSchema:
+  z.ZodType<
+    DestroyVirtualMachineNetworkAttachmentMeta$Outbound,
+    z.ZodTypeDef,
+    DestroyVirtualMachineNetworkAttachmentMeta
+  > = z.object({
+    status: z.string().optional(),
+  });
+
+export function destroyVirtualMachineNetworkAttachmentMetaToJSON(
+  destroyVirtualMachineNetworkAttachmentMeta:
+    DestroyVirtualMachineNetworkAttachmentMeta,
+): string {
+  return JSON.stringify(
+    DestroyVirtualMachineNetworkAttachmentMeta$outboundSchema.parse(
+      destroyVirtualMachineNetworkAttachmentMeta,
+    ),
+  );
+}
+export function destroyVirtualMachineNetworkAttachmentMetaFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  DestroyVirtualMachineNetworkAttachmentMeta,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DestroyVirtualMachineNetworkAttachmentMeta$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'DestroyVirtualMachineNetworkAttachmentMeta' from JSON`,
+  );
+}
+
+/** @internal */
+export const DestroyVirtualMachineNetworkAttachmentResponse$inboundSchema:
+  z.ZodType<
+    DestroyVirtualMachineNetworkAttachmentResponse,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    meta: z.lazy(() => DestroyVirtualMachineNetworkAttachmentMeta$inboundSchema)
+      .optional(),
+  });
+/** @internal */
+export type DestroyVirtualMachineNetworkAttachmentResponse$Outbound = {
+  meta?: DestroyVirtualMachineNetworkAttachmentMeta$Outbound | undefined;
+};
+
+/** @internal */
+export const DestroyVirtualMachineNetworkAttachmentResponse$outboundSchema:
+  z.ZodType<
+    DestroyVirtualMachineNetworkAttachmentResponse$Outbound,
+    z.ZodTypeDef,
+    DestroyVirtualMachineNetworkAttachmentResponse
+  > = z.object({
+    meta: z.lazy(() =>
+      DestroyVirtualMachineNetworkAttachmentMeta$outboundSchema
+    ).optional(),
+  });
+
+export function destroyVirtualMachineNetworkAttachmentResponseToJSON(
+  destroyVirtualMachineNetworkAttachmentResponse:
+    DestroyVirtualMachineNetworkAttachmentResponse,
+): string {
+  return JSON.stringify(
+    DestroyVirtualMachineNetworkAttachmentResponse$outboundSchema.parse(
+      destroyVirtualMachineNetworkAttachmentResponse,
+    ),
+  );
+}
+export function destroyVirtualMachineNetworkAttachmentResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  DestroyVirtualMachineNetworkAttachmentResponse,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DestroyVirtualMachineNetworkAttachmentResponse$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'DestroyVirtualMachineNetworkAttachmentResponse' from JSON`,
+  );
+}

package/src/models/operations/getevents.ts

@@ -52,15 +52,8 @@ export type GetEventsRequest = {
   pageNumber?: number | undefined;
 };
 
-/**
- * Success
- */
-export type GetEventsResponseBody = {
-  data?: Array<models.Events> | undefined;
-};
-
 export type GetEventsResponse = {
-  result: GetEventsResponseBody;
+  result: models.Events;
 };
 
 /** @internal */
@@ -155,52 +148,13 @@ export function getEventsRequestFromJSON(
   );
 }
 
-/** @internal */
-export const GetEventsResponseBody$inboundSchema: z.ZodType<
-  GetEventsResponseBody,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  data: z.array(models.Events$inboundSchema).optional(),
-});
-/** @internal */
-export type GetEventsResponseBody$Outbound = {
-  data?: Array<models.Events$Outbound> | undefined;
-};
-
-/** @internal */
-export const GetEventsResponseBody$outboundSchema: z.ZodType<
-  GetEventsResponseBody$Outbound,
-  z.ZodTypeDef,
-  GetEventsResponseBody
-> = z.object({
-  data: z.array(models.Events$outboundSchema).optional(),
-});
-
-export function getEventsResponseBodyToJSON(
-  getEventsResponseBody: GetEventsResponseBody,
-): string {
-  return JSON.stringify(
-    GetEventsResponseBody$outboundSchema.parse(getEventsResponseBody),
-  );
-}
-export function getEventsResponseBodyFromJSON(
-  jsonString: string,
-): SafeParseResult<GetEventsResponseBody, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => GetEventsResponseBody$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GetEventsResponseBody' from JSON`,
-  );
-}
-
 /** @internal */
 export const GetEventsResponse$inboundSchema: z.ZodType<
   GetEventsResponse,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  Result: z.lazy(() => GetEventsResponseBody$inboundSchema),
+  Result: models.Events$inboundSchema,
 }).transform((v) => {
   return remap$(v, {
     "Result": "result",
@@ -208,7 +162,7 @@ export const GetEventsResponse$inboundSchema: z.ZodType<
 });
 /** @internal */
 export type GetEventsResponse$Outbound = {
-  Result: GetEventsResponseBody$Outbound;
+  Result: models.Events$Outbound;
 };
 
 /** @internal */
@@ -217,7 +171,7 @@ export const GetEventsResponse$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   GetEventsResponse
 > = z.object({
-  result: z.lazy(() => GetEventsResponseBody$outboundSchema),
+  result: models.Events$outboundSchema,
 }).transform((v) => {
   return remap$(v, {
     result: "Result",

package/src/models/operations/getplansoperatingsystem.ts

@@ -20,15 +20,8 @@ export type GetPlansOperatingSystemRequest = {
   pageNumber?: number | undefined;
 };
 
-/**
- * Success
- */
-export type GetPlansOperatingSystemResponseBody = {
-  data?: Array<models.OperatingSystems> | undefined;
-};
-
 export type GetPlansOperatingSystemResponse = {
-  result: GetPlansOperatingSystemResponseBody;
+  result: models.OperatingSystems;
 };
 
 /** @internal */
@@ -85,55 +78,13 @@ export function getPlansOperatingSystemRequestFromJSON(
   );
 }
 
-/** @internal */
-export const GetPlansOperatingSystemResponseBody$inboundSchema: z.ZodType<
-  GetPlansOperatingSystemResponseBody,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  data: z.array(models.OperatingSystems$inboundSchema).optional(),
-});
-/** @internal */
-export type GetPlansOperatingSystemResponseBody$Outbound = {
-  data?: Array<models.OperatingSystems$Outbound> | undefined;
-};
-
-/** @internal */
-export const GetPlansOperatingSystemResponseBody$outboundSchema: z.ZodType<
-  GetPlansOperatingSystemResponseBody$Outbound,
-  z.ZodTypeDef,
-  GetPlansOperatingSystemResponseBody
-> = z.object({
-  data: z.array(models.OperatingSystems$outboundSchema).optional(),
-});
-
-export function getPlansOperatingSystemResponseBodyToJSON(
-  getPlansOperatingSystemResponseBody: GetPlansOperatingSystemResponseBody,
-): string {
-  return JSON.stringify(
-    GetPlansOperatingSystemResponseBody$outboundSchema.parse(
-      getPlansOperatingSystemResponseBody,
-    ),
-  );
-}
-export function getPlansOperatingSystemResponseBodyFromJSON(
-  jsonString: string,
-): SafeParseResult<GetPlansOperatingSystemResponseBody, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      GetPlansOperatingSystemResponseBody$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GetPlansOperatingSystemResponseBody' from JSON`,
-  );
-}
-
 /** @internal */
 export const GetPlansOperatingSystemResponse$inboundSchema: z.ZodType<
   GetPlansOperatingSystemResponse,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  Result: z.lazy(() => GetPlansOperatingSystemResponseBody$inboundSchema),
+  Result: models.OperatingSystems$inboundSchema,
 }).transform((v) => {
   return remap$(v, {
     "Result": "result",
@@ -141,7 +92,7 @@ export const GetPlansOperatingSystemResponse$inboundSchema: z.ZodType<
 });
 /** @internal */
 export type GetPlansOperatingSystemResponse$Outbound = {
-  Result: GetPlansOperatingSystemResponseBody$Outbound;
+  Result: models.OperatingSystems$Outbound;
 };
 
 /** @internal */
@@ -150,7 +101,7 @@ export const GetPlansOperatingSystemResponse$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   GetPlansOperatingSystemResponse
 > = z.object({
-  result: z.lazy(() => GetPlansOperatingSystemResponseBody$outboundSchema),
+  result: models.OperatingSystems$outboundSchema,
 }).transform((v) => {
   return remap$(v, {
     result: "Result",

package/src/models/operations/getprojectsshkeys.ts

@@ -17,6 +17,18 @@ export type GetProjectSshKeysRequest = {
    * The tags ids to filter by, separated by comma, e.g. `filter[tags]=tag_1,tag_2`will return ssh keys with `tag_1` AND `tag_2`
    */
   filterTags?: string | undefined;
+  /**
+   * Request aggregate stats in the response `meta`. Use `count` to get the total number of records, returned as `meta.stats.total.count`.
+   */
+  statsTotal?: string | undefined;
+  /**
+   * Page number for pagination
+   */
+  pageNumber?: number | undefined;
+  /**
+   * Number of items per page
+   */
+  pageSize?: number | undefined;
 };
 
 /** @internal */
@@ -27,16 +39,25 @@ export const GetProjectSshKeysRequest$inboundSchema: z.ZodType<
 > = z.object({
   project_id: z.string(),
   "filter[tags]": z.string().optional(),
+  "stats[total]": z.string().optional(),
+  "page[number]": z.number().int().optional(),
+  "page[size]": z.number().int().optional(),
 }).transform((v) => {
   return remap$(v, {
     "project_id": "projectId",
     "filter[tags]": "filterTags",
+    "stats[total]": "statsTotal",
+    "page[number]": "pageNumber",
+    "page[size]": "pageSize",
   });
 });
 /** @internal */
 export type GetProjectSshKeysRequest$Outbound = {
   project_id: string;
   "filter[tags]"?: string | undefined;
+  "stats[total]"?: string | undefined;
+  "page[number]"?: number | undefined;
+  "page[size]"?: number | undefined;
 };
 
 /** @internal */
@@ -47,10 +68,16 @@ export const GetProjectSshKeysRequest$outboundSchema: z.ZodType<
 > = z.object({
   projectId: z.string(),
   filterTags: z.string().optional(),
+  statsTotal: z.string().optional(),
+  pageNumber: z.number().int().optional(),
+  pageSize: z.number().int().optional(),
 }).transform((v) => {
   return remap$(v, {
     projectId: "project_id",
     filterTags: "filter[tags]",
+    statsTotal: "stats[total]",
+    pageNumber: "page[number]",
+    pageSize: "page[size]",
   });
 });
 

package/src/models/operations/getservers.ts

@@ -59,14 +59,17 @@ export type GetServersRequest = {
    */
   filterRamLte?: number | undefined;
   /**
-   * The disk size in Gigabytes to filter by, should be used with the following options:
-   *
-   * @remarks
-   *                               [eql] to filter for values equal to the provided value.
-   *                               [gte] to filter for values greater than or equal to the provided value.
-   *                               [lte] to filter by values lower than or equal to the provided value.
+   * Filter servers with disk size (in GB) equal to the provided value.
    */
-  filterDisk?: number | undefined;
+  filterDiskEql?: number | undefined;
+  /**
+   * Filter servers with disk size (in GB) greater than or equal to the provided value.
+   */
+  filterDiskGte?: number | undefined;
+  /**
+   * Filter servers with disk size (in GB) less than or equal to the provided value.
+   */
+  filterDiskLte?: number | undefined;
   /**
    * The tags IDs to filter by, separated by comma, e.g. `filter[tags]=tag_1,tag_2`will return servers with `tag_1` AND `tag_2`
    */
@@ -107,7 +110,9 @@ export const GetServersRequest$inboundSchema: z.ZodType<
   "filter[ram][eql]": z.number().int().optional(),
   "filter[ram][gte]": z.number().int().optional(),
   "filter[ram][lte]": z.number().int().optional(),
-  "filter[disk]": z.number().int().optional(),
+  "filter[disk][eql]": z.number().int().optional(),
+  "filter[disk][gte]": z.number().int().optional(),
+  "filter[disk][lte]": z.number().int().optional(),
   "filter[tags]": z.string().optional(),
   "extra_fields[servers]": z.string().optional(),
   "page[size]": z.number().int().default(20),
@@ -126,7 +131,9 @@ export const GetServersRequest$inboundSchema: z.ZodType<
     "filter[ram][eql]": "filterRamEql",
     "filter[ram][gte]": "filterRamGte",
     "filter[ram][lte]": "filterRamLte",
-    "filter[disk]": "filterDisk",
+    "filter[disk][eql]": "filterDiskEql",
+    "filter[disk][gte]": "filterDiskGte",
+    "filter[disk][lte]": "filterDiskLte",
     "filter[tags]": "filterTags",
     "extra_fields[servers]": "extraFieldsServers",
     "page[size]": "pageSize",
@@ -147,7 +154,9 @@ export type GetServersRequest$Outbound = {
   "filter[ram][eql]"?: number | undefined;
   "filter[ram][gte]"?: number | undefined;
   "filter[ram][lte]"?: number | undefined;
-  "filter[disk]"?: number | undefined;
+  "filter[disk][eql]"?: number | undefined;
+  "filter[disk][gte]"?: number | undefined;
+  "filter[disk][lte]"?: number | undefined;
   "filter[tags]"?: string | undefined;
   "extra_fields[servers]"?: string | undefined;
   "page[size]": number;
@@ -172,7 +181,9 @@ export const GetServersRequest$outboundSchema: z.ZodType<
   filterRamEql: z.number().int().optional(),
   filterRamGte: z.number().int().optional(),
   filterRamLte: z.number().int().optional(),
-  filterDisk: z.number().int().optional(),
+  filterDiskEql: z.number().int().optional(),
+  filterDiskGte: z.number().int().optional(),
+  filterDiskLte: z.number().int().optional(),
   filterTags: z.string().optional(),
   extraFieldsServers: z.string().optional(),
   pageSize: z.number().int().default(20),
@@ -191,7 +202,9 @@ export const GetServersRequest$outboundSchema: z.ZodType<
     filterRamEql: "filter[ram][eql]",
     filterRamGte: "filter[ram][gte]",
     filterRamLte: "filter[ram][lte]",
-    filterDisk: "filter[disk]",
+    filterDiskEql: "filter[disk][eql]",
+    filterDiskGte: "filter[disk][gte]",
+    filterDiskLte: "filter[disk][lte]",
     filterTags: "filter[tags]",
     extraFieldsServers: "extra_fields[servers]",
     pageSize: "page[size]",