latitudesh-typescript-sdk 0.4.1 → 0.5.0

package/src/models/deployconfig.ts

@@ -5,9 +5,37 @@
 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";
 
+export const DeployConfigRole = {
+  Os: "os",
+  Storage: "storage",
+  Raw: "raw",
+} as const;
+export type DeployConfigRole = ClosedEnum<typeof DeployConfigRole>;
+
+export const RaidLevel = {
+  Raid0: "raid-0",
+  Raid1: "raid-1",
+} as const;
+export type RaidLevel = ClosedEnum<typeof RaidLevel>;
+
+export const Filesystem = {
+  Ext4: "ext4",
+  Xfs: "xfs",
+} as const;
+export type Filesystem = ClosedEnum<typeof Filesystem>;
+
+export type DiskLayout = {
+  count: number;
+  role: DeployConfigRole;
+  raidLevel?: RaidLevel | null | undefined;
+  filesystem?: Filesystem | null | undefined;
+  mountPoint?: string | null | undefined;
+};
+
 export type Partition = {
   path?: string | undefined;
   sizeInGb?: number | undefined;
@@ -18,6 +46,7 @@ export type DeployConfigAttributes = {
   operatingSystem?: string | undefined;
   hostname?: string | undefined;
   raid?: string | undefined;
+  diskLayout?: Array<DiskLayout> | null | undefined;
   userData?: string | undefined;
   sshKeys?: Array<string> | undefined;
   partitions?: Array<Partition> | null | undefined;
@@ -32,6 +61,86 @@ export type DeployConfig = {
   data?: DeployConfigData | undefined;
 };
 
+/** @internal */
+export const DeployConfigRole$inboundSchema: z.ZodNativeEnum<
+  typeof DeployConfigRole
+> = z.nativeEnum(DeployConfigRole);
+/** @internal */
+export const DeployConfigRole$outboundSchema: z.ZodNativeEnum<
+  typeof DeployConfigRole
+> = DeployConfigRole$inboundSchema;
+
+/** @internal */
+export const RaidLevel$inboundSchema: z.ZodNativeEnum<typeof RaidLevel> = z
+  .nativeEnum(RaidLevel);
+/** @internal */
+export const RaidLevel$outboundSchema: z.ZodNativeEnum<typeof RaidLevel> =
+  RaidLevel$inboundSchema;
+
+/** @internal */
+export const Filesystem$inboundSchema: z.ZodNativeEnum<typeof Filesystem> = z
+  .nativeEnum(Filesystem);
+/** @internal */
+export const Filesystem$outboundSchema: z.ZodNativeEnum<typeof Filesystem> =
+  Filesystem$inboundSchema;
+
+/** @internal */
+export const DiskLayout$inboundSchema: z.ZodType<
+  DiskLayout,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  count: z.number().int(),
+  role: DeployConfigRole$inboundSchema,
+  raid_level: z.nullable(RaidLevel$inboundSchema).optional(),
+  filesystem: z.nullable(Filesystem$inboundSchema).optional(),
+  mount_point: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "raid_level": "raidLevel",
+    "mount_point": "mountPoint",
+  });
+});
+/** @internal */
+export type DiskLayout$Outbound = {
+  count: number;
+  role: string;
+  raid_level?: string | null | undefined;
+  filesystem?: string | null | undefined;
+  mount_point?: string | null | undefined;
+};
+
+/** @internal */
+export const DiskLayout$outboundSchema: z.ZodType<
+  DiskLayout$Outbound,
+  z.ZodTypeDef,
+  DiskLayout
+> = z.object({
+  count: z.number().int(),
+  role: DeployConfigRole$outboundSchema,
+  raidLevel: z.nullable(RaidLevel$outboundSchema).optional(),
+  filesystem: z.nullable(Filesystem$outboundSchema).optional(),
+  mountPoint: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    raidLevel: "raid_level",
+    mountPoint: "mount_point",
+  });
+});
+
+export function diskLayoutToJSON(diskLayout: DiskLayout): string {
+  return JSON.stringify(DiskLayout$outboundSchema.parse(diskLayout));
+}
+export function diskLayoutFromJSON(
+  jsonString: string,
+): SafeParseResult<DiskLayout, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DiskLayout$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DiskLayout' from JSON`,
+  );
+}
+
 /** @internal */
 export const Partition$inboundSchema: z.ZodType<
   Partition,
@@ -92,6 +201,8 @@ export const DeployConfigAttributes$inboundSchema: z.ZodType<
   operating_system: z.string().optional(),
   hostname: z.string().optional(),
   raid: z.string().optional(),
+  disk_layout: z.nullable(z.array(z.lazy(() => DiskLayout$inboundSchema)))
+    .optional(),
   user_data: z.string().optional(),
   ssh_keys: z.array(z.string()).optional(),
   partitions: z.nullable(z.array(z.lazy(() => Partition$inboundSchema)))
@@ -99,6 +210,7 @@ export const DeployConfigAttributes$inboundSchema: z.ZodType<
 }).transform((v) => {
   return remap$(v, {
     "operating_system": "operatingSystem",
+    "disk_layout": "diskLayout",
     "user_data": "userData",
     "ssh_keys": "sshKeys",
   });
@@ -108,6 +220,7 @@ export type DeployConfigAttributes$Outbound = {
   operating_system?: string | undefined;
   hostname?: string | undefined;
   raid?: string | undefined;
+  disk_layout?: Array<DiskLayout$Outbound> | null | undefined;
   user_data?: string | undefined;
   ssh_keys?: Array<string> | undefined;
   partitions?: Array<Partition$Outbound> | null | undefined;
@@ -122,6 +235,8 @@ export const DeployConfigAttributes$outboundSchema: z.ZodType<
   operatingSystem: z.string().optional(),
   hostname: z.string().optional(),
   raid: z.string().optional(),
+  diskLayout: z.nullable(z.array(z.lazy(() => DiskLayout$outboundSchema)))
+    .optional(),
   userData: z.string().optional(),
   sshKeys: z.array(z.string()).optional(),
   partitions: z.nullable(z.array(z.lazy(() => Partition$outboundSchema)))
@@ -129,6 +244,7 @@ export const DeployConfigAttributes$outboundSchema: z.ZodType<
 }).transform((v) => {
   return remap$(v, {
     operatingSystem: "operating_system",
+    diskLayout: "disk_layout",
     userData: "user_data",
     sshKeys: "ssh_keys",
   });

package/src/models/index.ts

@@ -45,6 +45,7 @@ export * from "./objectstorages.js";
 export * from "./operatingsystemdata.js";
 export * from "./operatingsystems.js";
 export * from "./outofbandconnection.js";
+export * from "./paginationmeta.js";
 export * from "./plan.js";
 export * from "./plandata.js";
 export * from "./project.js";
@@ -86,6 +87,10 @@ export * from "./userteams.js";
 export * from "./userupdate.js";
 export * from "./virtualmachine.js";
 export * from "./virtualmachineattributes.js";
+export * from "./virtualmachinemetrics.js";
+export * from "./virtualmachinenetworkattachmentcreatepayload.js";
+export * from "./virtualmachinenetworkattachmentresource.js";
+export * from "./virtualmachinenetworkattachments.js";
 export * from "./virtualmachinepayload.js";
 export * from "./virtualmachineplans.js";
 export * from "./virtualmachines.js";

package/src/models/operatingsystemdata.ts

@@ -10,7 +10,7 @@ import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
 export const OperatingSystemDataType = {
-  OperatingSystems: "operating_systems",
+  OperatingSystem: "operating_system",
 } as const;
 export type OperatingSystemDataType = ClosedEnum<
   typeof OperatingSystemDataType

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/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",