latitudesh-typescript-sdk 0.8.29 → 0.8.31

package/src/models/operations/updatevolume.ts

@@ -0,0 +1,312 @@
+/*
+ * 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 { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import * as models from "../index.js";
+
+export const UpdateVolumeType2 = {
+  Volumes: "volumes",
+} as const;
+export type UpdateVolumeType2 = ClosedEnum<typeof UpdateVolumeType2>;
+
+export type UpdateVolumeAttributes2 = {
+  /**
+   * New size in GB. Must be larger than the current size.
+   */
+  sizeInGb: number;
+};
+
+export type UpdateVolumeData2 = {
+  type: UpdateVolumeType2;
+  attributes: UpdateVolumeAttributes2;
+};
+
+export type UpdateVolumeRequestBody2 = {
+  data: UpdateVolumeData2;
+};
+
+export type UpdateVolumeRequest = {
+  /**
+   * Volume ID
+   */
+  id: string;
+  requestBody: UpdateVolumeRequestBody2;
+};
+
+export type UpdateVolumeMeta = {};
+
+/**
+ * Success
+ */
+export type UpdateVolumeResponse = {
+  data?: models.VolumeData | undefined;
+  meta?: UpdateVolumeMeta | undefined;
+};
+
+/** @internal */
+export const UpdateVolumeType2$inboundSchema: z.ZodNativeEnum<
+  typeof UpdateVolumeType2
+> = z.nativeEnum(UpdateVolumeType2);
+/** @internal */
+export const UpdateVolumeType2$outboundSchema: z.ZodNativeEnum<
+  typeof UpdateVolumeType2
+> = UpdateVolumeType2$inboundSchema;
+
+/** @internal */
+export const UpdateVolumeAttributes2$inboundSchema: z.ZodType<
+  UpdateVolumeAttributes2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  size_in_gb: z.number().int(),
+}).transform((v) => {
+  return remap$(v, {
+    "size_in_gb": "sizeInGb",
+  });
+});
+/** @internal */
+export type UpdateVolumeAttributes2$Outbound = {
+  size_in_gb: number;
+};
+
+/** @internal */
+export const UpdateVolumeAttributes2$outboundSchema: z.ZodType<
+  UpdateVolumeAttributes2$Outbound,
+  z.ZodTypeDef,
+  UpdateVolumeAttributes2
+> = z.object({
+  sizeInGb: z.number().int(),
+}).transform((v) => {
+  return remap$(v, {
+    sizeInGb: "size_in_gb",
+  });
+});
+
+export function updateVolumeAttributes2ToJSON(
+  updateVolumeAttributes2: UpdateVolumeAttributes2,
+): string {
+  return JSON.stringify(
+    UpdateVolumeAttributes2$outboundSchema.parse(updateVolumeAttributes2),
+  );
+}
+export function updateVolumeAttributes2FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateVolumeAttributes2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateVolumeAttributes2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateVolumeAttributes2' from JSON`,
+  );
+}
+
+/** @internal */
+export const UpdateVolumeData2$inboundSchema: z.ZodType<
+  UpdateVolumeData2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: UpdateVolumeType2$inboundSchema,
+  attributes: z.lazy(() => UpdateVolumeAttributes2$inboundSchema),
+});
+/** @internal */
+export type UpdateVolumeData2$Outbound = {
+  type: string;
+  attributes: UpdateVolumeAttributes2$Outbound;
+};
+
+/** @internal */
+export const UpdateVolumeData2$outboundSchema: z.ZodType<
+  UpdateVolumeData2$Outbound,
+  z.ZodTypeDef,
+  UpdateVolumeData2
+> = z.object({
+  type: UpdateVolumeType2$outboundSchema,
+  attributes: z.lazy(() => UpdateVolumeAttributes2$outboundSchema),
+});
+
+export function updateVolumeData2ToJSON(
+  updateVolumeData2: UpdateVolumeData2,
+): string {
+  return JSON.stringify(
+    UpdateVolumeData2$outboundSchema.parse(updateVolumeData2),
+  );
+}
+export function updateVolumeData2FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateVolumeData2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateVolumeData2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateVolumeData2' from JSON`,
+  );
+}
+
+/** @internal */
+export const UpdateVolumeRequestBody2$inboundSchema: z.ZodType<
+  UpdateVolumeRequestBody2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.lazy(() => UpdateVolumeData2$inboundSchema),
+});
+/** @internal */
+export type UpdateVolumeRequestBody2$Outbound = {
+  data: UpdateVolumeData2$Outbound;
+};
+
+/** @internal */
+export const UpdateVolumeRequestBody2$outboundSchema: z.ZodType<
+  UpdateVolumeRequestBody2$Outbound,
+  z.ZodTypeDef,
+  UpdateVolumeRequestBody2
+> = z.object({
+  data: z.lazy(() => UpdateVolumeData2$outboundSchema),
+});
+
+export function updateVolumeRequestBody2ToJSON(
+  updateVolumeRequestBody2: UpdateVolumeRequestBody2,
+): string {
+  return JSON.stringify(
+    UpdateVolumeRequestBody2$outboundSchema.parse(updateVolumeRequestBody2),
+  );
+}
+export function updateVolumeRequestBody2FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateVolumeRequestBody2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateVolumeRequestBody2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateVolumeRequestBody2' from JSON`,
+  );
+}
+
+/** @internal */
+export const UpdateVolumeRequest$inboundSchema: z.ZodType<
+  UpdateVolumeRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  RequestBody: z.lazy(() => UpdateVolumeRequestBody2$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "RequestBody": "requestBody",
+  });
+});
+/** @internal */
+export type UpdateVolumeRequest$Outbound = {
+  id: string;
+  RequestBody: UpdateVolumeRequestBody2$Outbound;
+};
+
+/** @internal */
+export const UpdateVolumeRequest$outboundSchema: z.ZodType<
+  UpdateVolumeRequest$Outbound,
+  z.ZodTypeDef,
+  UpdateVolumeRequest
+> = z.object({
+  id: z.string(),
+  requestBody: z.lazy(() => UpdateVolumeRequestBody2$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    requestBody: "RequestBody",
+  });
+});
+
+export function updateVolumeRequestToJSON(
+  updateVolumeRequest: UpdateVolumeRequest,
+): string {
+  return JSON.stringify(
+    UpdateVolumeRequest$outboundSchema.parse(updateVolumeRequest),
+  );
+}
+export function updateVolumeRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateVolumeRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateVolumeRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateVolumeRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const UpdateVolumeMeta$inboundSchema: z.ZodType<
+  UpdateVolumeMeta,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+/** @internal */
+export type UpdateVolumeMeta$Outbound = {};
+
+/** @internal */
+export const UpdateVolumeMeta$outboundSchema: z.ZodType<
+  UpdateVolumeMeta$Outbound,
+  z.ZodTypeDef,
+  UpdateVolumeMeta
+> = z.object({});
+
+export function updateVolumeMetaToJSON(
+  updateVolumeMeta: UpdateVolumeMeta,
+): string {
+  return JSON.stringify(
+    UpdateVolumeMeta$outboundSchema.parse(updateVolumeMeta),
+  );
+}
+export function updateVolumeMetaFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateVolumeMeta, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateVolumeMeta$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateVolumeMeta' from JSON`,
+  );
+}
+
+/** @internal */
+export const UpdateVolumeResponse$inboundSchema: z.ZodType<
+  UpdateVolumeResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: models.VolumeData$inboundSchema.optional(),
+  meta: z.lazy(() => UpdateVolumeMeta$inboundSchema).optional(),
+});
+/** @internal */
+export type UpdateVolumeResponse$Outbound = {
+  data?: models.VolumeData$Outbound | undefined;
+  meta?: UpdateVolumeMeta$Outbound | undefined;
+};
+
+/** @internal */
+export const UpdateVolumeResponse$outboundSchema: z.ZodType<
+  UpdateVolumeResponse$Outbound,
+  z.ZodTypeDef,
+  UpdateVolumeResponse
+> = z.object({
+  data: models.VolumeData$outboundSchema.optional(),
+  meta: z.lazy(() => UpdateVolumeMeta$outboundSchema).optional(),
+});
+
+export function updateVolumeResponseToJSON(
+  updateVolumeResponse: UpdateVolumeResponse,
+): string {
+  return JSON.stringify(
+    UpdateVolumeResponse$outboundSchema.parse(updateVolumeResponse),
+  );
+}
+export function updateVolumeResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateVolumeResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateVolumeResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateVolumeResponse' from JSON`,
+  );
+}

package/src/models/publicnetworkdata.ts

@@ -9,10 +9,12 @@ import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
-export const PublicNetworkDataType = {
+export const PublicNetworkDataTypePublicNetworks = {
   PublicNetworks: "public_networks",
 } as const;
-export type PublicNetworkDataType = ClosedEnum<typeof PublicNetworkDataType>;
+export type PublicNetworkDataTypePublicNetworks = ClosedEnum<
+  typeof PublicNetworkDataTypePublicNetworks
+>;
 
 /**
  * IPv4 prefix length. Determines how many servers the public network can host.
@@ -28,6 +30,51 @@ export const PublicNetworkDataSize = {
  */
 export type PublicNetworkDataSize = ClosedEnum<typeof PublicNetworkDataSize>;
 
+/**
+ * gateway: reserved for the network gateway; server: a server on the network; elastic_ip: an elastic IP; reserved: held in IPAM but not by a server, including addresses you reserved; available: free to use
+ */
+export const PublicNetworkDataRole = {
+  Gateway: "gateway",
+  Server: "server",
+  ElasticIp: "elastic_ip",
+  Reserved: "reserved",
+  Available: "available",
+} as const;
+/**
+ * gateway: reserved for the network gateway; server: a server on the network; elastic_ip: an elastic IP; reserved: held in IPAM but not by a server, including addresses you reserved; available: free to use
+ */
+export type PublicNetworkDataRole = ClosedEnum<typeof PublicNetworkDataRole>;
+
+export const AssignmentType = {
+  Server: "server",
+  ElasticIp: "elastic_ip",
+} as const;
+export type AssignmentType = ClosedEnum<typeof AssignmentType>;
+
+/**
+ * The resource holding the address, when it is a server or an elastic IP
+ */
+export type PublicNetworkDataAssignment = {
+  type?: AssignmentType | undefined;
+  id?: string | undefined;
+  /**
+   * Servers only
+   */
+  hostname?: string | null | undefined;
+};
+
+export type Ip = {
+  address?: string | undefined;
+  /**
+   * gateway: reserved for the network gateway; server: a server on the network; elastic_ip: an elastic IP; reserved: held in IPAM but not by a server, including addresses you reserved; available: free to use
+   */
+  role?: PublicNetworkDataRole | undefined;
+  /**
+   * The resource holding the address, when it is a server or an elastic IP
+   */
+  assignment?: PublicNetworkDataAssignment | null | undefined;
+};
+
 export type PublicNetworkDataProject = {
   id?: string | undefined;
   name?: string | undefined;
@@ -69,6 +116,10 @@ export type PublicNetworkDataAttributes = {
   capacity?: number | undefined;
   ipsUsed?: number | undefined;
   ipsFree?: number | undefined;
+  /**
+   * Every host address of the IPv4 network and what holds it. Only returned when retrieving a single public network.
+   */
+  ips?: Array<Ip> | undefined;
   createdAt?: Date | undefined;
   project?: PublicNetworkDataProject | null | undefined;
   region?: PublicNetworkDataRegion | null | undefined;
@@ -76,18 +127,18 @@ export type PublicNetworkDataAttributes = {
 
 export type PublicNetworkData = {
   id?: string | undefined;
-  type?: PublicNetworkDataType | undefined;
+  type?: PublicNetworkDataTypePublicNetworks | undefined;
   attributes?: PublicNetworkDataAttributes | undefined;
 };
 
 /** @internal */
-export const PublicNetworkDataType$inboundSchema: z.ZodNativeEnum<
-  typeof PublicNetworkDataType
-> = z.nativeEnum(PublicNetworkDataType);
+export const PublicNetworkDataTypePublicNetworks$inboundSchema: z.ZodNativeEnum<
+  typeof PublicNetworkDataTypePublicNetworks
+> = z.nativeEnum(PublicNetworkDataTypePublicNetworks);
 /** @internal */
-export const PublicNetworkDataType$outboundSchema: z.ZodNativeEnum<
-  typeof PublicNetworkDataType
-> = PublicNetworkDataType$inboundSchema;
+export const PublicNetworkDataTypePublicNetworks$outboundSchema:
+  z.ZodNativeEnum<typeof PublicNetworkDataTypePublicNetworks> =
+    PublicNetworkDataTypePublicNetworks$inboundSchema;
 
 /** @internal */
 export const PublicNetworkDataSize$inboundSchema: z.ZodNativeEnum<
@@ -98,6 +149,109 @@ export const PublicNetworkDataSize$outboundSchema: z.ZodNativeEnum<
   typeof PublicNetworkDataSize
 > = PublicNetworkDataSize$inboundSchema;
 
+/** @internal */
+export const PublicNetworkDataRole$inboundSchema: z.ZodNativeEnum<
+  typeof PublicNetworkDataRole
+> = z.nativeEnum(PublicNetworkDataRole);
+/** @internal */
+export const PublicNetworkDataRole$outboundSchema: z.ZodNativeEnum<
+  typeof PublicNetworkDataRole
+> = PublicNetworkDataRole$inboundSchema;
+
+/** @internal */
+export const AssignmentType$inboundSchema: z.ZodNativeEnum<
+  typeof AssignmentType
+> = z.nativeEnum(AssignmentType);
+/** @internal */
+export const AssignmentType$outboundSchema: z.ZodNativeEnum<
+  typeof AssignmentType
+> = AssignmentType$inboundSchema;
+
+/** @internal */
+export const PublicNetworkDataAssignment$inboundSchema: z.ZodType<
+  PublicNetworkDataAssignment,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: AssignmentType$inboundSchema.optional(),
+  id: z.string().optional(),
+  hostname: z.nullable(z.string()).optional(),
+});
+/** @internal */
+export type PublicNetworkDataAssignment$Outbound = {
+  type?: string | undefined;
+  id?: string | undefined;
+  hostname?: string | null | undefined;
+};
+
+/** @internal */
+export const PublicNetworkDataAssignment$outboundSchema: z.ZodType<
+  PublicNetworkDataAssignment$Outbound,
+  z.ZodTypeDef,
+  PublicNetworkDataAssignment
+> = z.object({
+  type: AssignmentType$outboundSchema.optional(),
+  id: z.string().optional(),
+  hostname: z.nullable(z.string()).optional(),
+});
+
+export function publicNetworkDataAssignmentToJSON(
+  publicNetworkDataAssignment: PublicNetworkDataAssignment,
+): string {
+  return JSON.stringify(
+    PublicNetworkDataAssignment$outboundSchema.parse(
+      publicNetworkDataAssignment,
+    ),
+  );
+}
+export function publicNetworkDataAssignmentFromJSON(
+  jsonString: string,
+): SafeParseResult<PublicNetworkDataAssignment, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PublicNetworkDataAssignment$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PublicNetworkDataAssignment' from JSON`,
+  );
+}
+
+/** @internal */
+export const Ip$inboundSchema: z.ZodType<Ip, z.ZodTypeDef, unknown> = z.object({
+  address: z.string().optional(),
+  role: PublicNetworkDataRole$inboundSchema.optional(),
+  assignment: z.nullable(
+    z.lazy(() => PublicNetworkDataAssignment$inboundSchema),
+  ).optional(),
+});
+/** @internal */
+export type Ip$Outbound = {
+  address?: string | undefined;
+  role?: string | undefined;
+  assignment?: PublicNetworkDataAssignment$Outbound | null | undefined;
+};
+
+/** @internal */
+export const Ip$outboundSchema: z.ZodType<Ip$Outbound, z.ZodTypeDef, Ip> = z
+  .object({
+    address: z.string().optional(),
+    role: PublicNetworkDataRole$outboundSchema.optional(),
+    assignment: z.nullable(
+      z.lazy(() => PublicNetworkDataAssignment$outboundSchema),
+    ).optional(),
+  });
+
+export function ipToJSON(ip: Ip): string {
+  return JSON.stringify(Ip$outboundSchema.parse(ip));
+}
+export function ipFromJSON(
+  jsonString: string,
+): SafeParseResult<Ip, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Ip$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Ip' from JSON`,
+  );
+}
+
 /** @internal */
 export const PublicNetworkDataProject$inboundSchema: z.ZodType<
   PublicNetworkDataProject,
@@ -246,6 +400,7 @@ export const PublicNetworkDataAttributes$inboundSchema: z.ZodType<
   capacity: z.number().int().optional(),
   ips_used: z.number().int().optional(),
   ips_free: z.number().int().optional(),
+  ips: z.array(z.lazy(() => Ip$inboundSchema)).optional(),
   created_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
   project: z.nullable(z.lazy(() => PublicNetworkDataProject$inboundSchema))
@@ -268,6 +423,7 @@ export type PublicNetworkDataAttributes$Outbound = {
   capacity?: number | undefined;
   ips_used?: number | undefined;
   ips_free?: number | undefined;
+  ips?: Array<Ip$Outbound> | undefined;
   created_at?: string | undefined;
   project?: PublicNetworkDataProject$Outbound | null | undefined;
   region?: PublicNetworkDataRegion$Outbound | null | undefined;
@@ -286,6 +442,7 @@ export const PublicNetworkDataAttributes$outboundSchema: z.ZodType<
   capacity: z.number().int().optional(),
   ipsUsed: z.number().int().optional(),
   ipsFree: z.number().int().optional(),
+  ips: z.array(z.lazy(() => Ip$outboundSchema)).optional(),
   createdAt: z.date().transform(v => v.toISOString()).optional(),
   project: z.nullable(z.lazy(() => PublicNetworkDataProject$outboundSchema))
     .optional(),
@@ -325,7 +482,7 @@ export const PublicNetworkData$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: PublicNetworkDataType$inboundSchema.optional(),
+  type: PublicNetworkDataTypePublicNetworks$inboundSchema.optional(),
   attributes: z.lazy(() => PublicNetworkDataAttributes$inboundSchema)
     .optional(),
 });
@@ -343,7 +500,7 @@ export const PublicNetworkData$outboundSchema: z.ZodType<
   PublicNetworkData
 > = z.object({
   id: z.string().optional(),
-  type: PublicNetworkDataType$outboundSchema.optional(),
+  type: PublicNetworkDataTypePublicNetworks$outboundSchema.optional(),
   attributes: z.lazy(() => PublicNetworkDataAttributes$outboundSchema)
     .optional(),
 });

package/src/models/region.ts

@@ -27,7 +27,7 @@ export type RegionAttributes = {
   country?: RegionCountry | undefined;
   type?: string | null | undefined;
   /**
-   * Location capabilities available at this location (e.g. `public_network`, `elastic_ip_bgp`).
+   * Location capabilities available at this location (e.g. `public_network`, `elastic_ip_bgp`, `object_storage`, `object_storage_high_performance`, `file_storage`, `block_storage`, `lks`).
    */
   features?: Array<string> | undefined;
   /**

package/src/models/regions.ts

@@ -33,7 +33,7 @@ export type RegionsAttributes = {
   country?: Country | undefined;
   type?: string | null | undefined;
   /**
-   * Location capabilities available at this location (e.g. `public_network`, `elastic_ip_bgp`).
+   * Location capabilities available at this location (e.g. `public_network`, `elastic_ip_bgp`, `object_storage`, `object_storage_high_performance`, `file_storage`, `block_storage`, `lks`).
    */
   features?: Array<string> | undefined;
   /**

package/src/models/updatelksnodepool.ts

@@ -21,14 +21,18 @@ export const UpdateLksNodePoolType = {
 export type UpdateLksNodePoolType = ClosedEnum<typeof UpdateLksNodePoolType>;
 
 /**
- * At least one attribute must be provided. max_pods_per_node is set once, at creation, and is not updatable: a PATCH that carries it is rejected with 422.
+ * At least one attribute must be provided. max_pods_per_node and mode are set once, at creation, and are not updatable: a PATCH that carries either is rejected with 422.
  */
 export type UpdateLksNodePoolAttributes = {
   name?: string | undefined;
   /**
-   * must be >= 1
+   * must be >= 1. on_demand node pools only; rejected for allocated node pools
    */
   count?: number | undefined;
+  /**
+   * Allocated node pools only. Declarative: send the whole set of servers the pool should have. Added servers are checked like on create and reinstalled to join; removed servers are drained and reinstalled with a clean OS. Cannot be combined with a kubernetes_version change.
+   */
+  serverIds?: Array<string> | undefined;
   /**
    * A newer patch rolls a node-recreating upgrade. Must not be lower than the current patch (422 DOWNGRADE_NOT_ALLOWED) nor newer than the control-plane patch (422 VERSION_SKEW)
    */
@@ -47,7 +51,7 @@ export type UpdateLksNodePoolAttributes = {
 export type UpdateLksNodePoolData = {
   type: UpdateLksNodePoolType;
   /**
-   * At least one attribute must be provided. max_pods_per_node is set once, at creation, and is not updatable: a PATCH that carries it is rejected with 422.
+   * At least one attribute must be provided. max_pods_per_node and mode are set once, at creation, and are not updatable: a PATCH that carries either is rejected with 422.
    */
   attributes?: UpdateLksNodePoolAttributes | undefined;
 };
@@ -73,12 +77,14 @@ export const UpdateLksNodePoolAttributes$inboundSchema: z.ZodType<
 > = z.object({
   name: z.string().optional(),
   count: z.number().int().optional(),
+  server_ids: z.array(z.string()).optional(),
   kubernetes_version: z.string().optional(),
   labels: z.record(z.string()).optional(),
   taints: z.array(LksNodePoolTaint$inboundSchema).optional(),
   description: z.string().optional(),
 }).transform((v) => {
   return remap$(v, {
+    "server_ids": "serverIds",
     "kubernetes_version": "kubernetesVersion",
   });
 });
@@ -86,6 +92,7 @@ export const UpdateLksNodePoolAttributes$inboundSchema: z.ZodType<
 export type UpdateLksNodePoolAttributes$Outbound = {
   name?: string | undefined;
   count?: number | undefined;
+  server_ids?: Array<string> | undefined;
   kubernetes_version?: string | undefined;
   labels?: { [k: string]: string } | undefined;
   taints?: Array<LksNodePoolTaint$Outbound> | undefined;
@@ -100,12 +107,14 @@ export const UpdateLksNodePoolAttributes$outboundSchema: z.ZodType<
 > = z.object({
   name: z.string().optional(),
   count: z.number().int().optional(),
+  serverIds: z.array(z.string()).optional(),
   kubernetesVersion: z.string().optional(),
   labels: z.record(z.string()).optional(),
   taints: z.array(LksNodePoolTaint$outboundSchema).optional(),
   description: z.string().optional(),
 }).transform((v) => {
   return remap$(v, {
+    serverIds: "server_ids",
     kubernetesVersion: "kubernetes_version",
   });
 });