latitudesh-typescript-sdk 0.6.2 → 0.7.0

package/src/models/virtualmachinebackupattributes.ts

@@ -0,0 +1,275 @@
+/*
+ * 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 {
+  ProjectInclude,
+  ProjectInclude$inboundSchema,
+  ProjectInclude$Outbound,
+  ProjectInclude$outboundSchema,
+} from "./projectinclude.js";
+import {
+  TeamInclude,
+  TeamInclude$inboundSchema,
+  TeamInclude$Outbound,
+  TeamInclude$outboundSchema,
+} from "./teaminclude.js";
+
+export const VirtualMachineBackupAttributesType = {
+  VirtualMachineBackups: "virtual_machine_backups",
+} as const;
+export type VirtualMachineBackupAttributesType = ClosedEnum<
+  typeof VirtualMachineBackupAttributesType
+>;
+
+export const VirtualMachineBackupAttributesStatus = {
+  Creating: "Creating",
+  Ready: "Ready",
+  Failed: "Failed",
+  Archived: "Archived",
+} as const;
+export type VirtualMachineBackupAttributesStatus = ClosedEnum<
+  typeof VirtualMachineBackupAttributesStatus
+>;
+
+export type VirtualMachineBackupAttributesVirtualMachine = {
+  id?: string | undefined;
+  name?: string | undefined;
+};
+
+export type VirtualMachineBackupAttributesAttributes = {
+  status?: VirtualMachineBackupAttributesStatus | undefined;
+  sizeBytes?: number | null | undefined;
+  expiresAt?: string | null | undefined;
+  failureReason?: string | null | undefined;
+  createdAt?: string | undefined;
+  virtualMachine?: VirtualMachineBackupAttributesVirtualMachine | undefined;
+  team?: TeamInclude | undefined;
+  project?: ProjectInclude | undefined;
+};
+
+export type VirtualMachineBackupAttributes = {
+  id?: string | undefined;
+  type?: VirtualMachineBackupAttributesType | undefined;
+  attributes?: VirtualMachineBackupAttributesAttributes | undefined;
+};
+
+/** @internal */
+export const VirtualMachineBackupAttributesType$inboundSchema: z.ZodNativeEnum<
+  typeof VirtualMachineBackupAttributesType
+> = z.nativeEnum(VirtualMachineBackupAttributesType);
+/** @internal */
+export const VirtualMachineBackupAttributesType$outboundSchema: z.ZodNativeEnum<
+  typeof VirtualMachineBackupAttributesType
+> = VirtualMachineBackupAttributesType$inboundSchema;
+
+/** @internal */
+export const VirtualMachineBackupAttributesStatus$inboundSchema:
+  z.ZodNativeEnum<typeof VirtualMachineBackupAttributesStatus> = z.nativeEnum(
+    VirtualMachineBackupAttributesStatus,
+  );
+/** @internal */
+export const VirtualMachineBackupAttributesStatus$outboundSchema:
+  z.ZodNativeEnum<typeof VirtualMachineBackupAttributesStatus> =
+    VirtualMachineBackupAttributesStatus$inboundSchema;
+
+/** @internal */
+export const VirtualMachineBackupAttributesVirtualMachine$inboundSchema:
+  z.ZodType<
+    VirtualMachineBackupAttributesVirtualMachine,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    id: z.string().optional(),
+    name: z.string().optional(),
+  });
+/** @internal */
+export type VirtualMachineBackupAttributesVirtualMachine$Outbound = {
+  id?: string | undefined;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const VirtualMachineBackupAttributesVirtualMachine$outboundSchema:
+  z.ZodType<
+    VirtualMachineBackupAttributesVirtualMachine$Outbound,
+    z.ZodTypeDef,
+    VirtualMachineBackupAttributesVirtualMachine
+  > = z.object({
+    id: z.string().optional(),
+    name: z.string().optional(),
+  });
+
+export function virtualMachineBackupAttributesVirtualMachineToJSON(
+  virtualMachineBackupAttributesVirtualMachine:
+    VirtualMachineBackupAttributesVirtualMachine,
+): string {
+  return JSON.stringify(
+    VirtualMachineBackupAttributesVirtualMachine$outboundSchema.parse(
+      virtualMachineBackupAttributesVirtualMachine,
+    ),
+  );
+}
+export function virtualMachineBackupAttributesVirtualMachineFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  VirtualMachineBackupAttributesVirtualMachine,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      VirtualMachineBackupAttributesVirtualMachine$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'VirtualMachineBackupAttributesVirtualMachine' from JSON`,
+  );
+}
+
+/** @internal */
+export const VirtualMachineBackupAttributesAttributes$inboundSchema: z.ZodType<
+  VirtualMachineBackupAttributesAttributes,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  status: VirtualMachineBackupAttributesStatus$inboundSchema.optional(),
+  size_bytes: z.nullable(z.number().int()).optional(),
+  expires_at: z.nullable(z.string()).optional(),
+  failure_reason: z.nullable(z.string()).optional(),
+  created_at: z.string().optional(),
+  virtual_machine: z.lazy(() =>
+    VirtualMachineBackupAttributesVirtualMachine$inboundSchema
+  ).optional(),
+  team: TeamInclude$inboundSchema.optional(),
+  project: ProjectInclude$inboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "size_bytes": "sizeBytes",
+    "expires_at": "expiresAt",
+    "failure_reason": "failureReason",
+    "created_at": "createdAt",
+    "virtual_machine": "virtualMachine",
+  });
+});
+/** @internal */
+export type VirtualMachineBackupAttributesAttributes$Outbound = {
+  status?: string | undefined;
+  size_bytes?: number | null | undefined;
+  expires_at?: string | null | undefined;
+  failure_reason?: string | null | undefined;
+  created_at?: string | undefined;
+  virtual_machine?:
+    | VirtualMachineBackupAttributesVirtualMachine$Outbound
+    | undefined;
+  team?: TeamInclude$Outbound | undefined;
+  project?: ProjectInclude$Outbound | undefined;
+};
+
+/** @internal */
+export const VirtualMachineBackupAttributesAttributes$outboundSchema: z.ZodType<
+  VirtualMachineBackupAttributesAttributes$Outbound,
+  z.ZodTypeDef,
+  VirtualMachineBackupAttributesAttributes
+> = z.object({
+  status: VirtualMachineBackupAttributesStatus$outboundSchema.optional(),
+  sizeBytes: z.nullable(z.number().int()).optional(),
+  expiresAt: z.nullable(z.string()).optional(),
+  failureReason: z.nullable(z.string()).optional(),
+  createdAt: z.string().optional(),
+  virtualMachine: z.lazy(() =>
+    VirtualMachineBackupAttributesVirtualMachine$outboundSchema
+  ).optional(),
+  team: TeamInclude$outboundSchema.optional(),
+  project: ProjectInclude$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    sizeBytes: "size_bytes",
+    expiresAt: "expires_at",
+    failureReason: "failure_reason",
+    createdAt: "created_at",
+    virtualMachine: "virtual_machine",
+  });
+});
+
+export function virtualMachineBackupAttributesAttributesToJSON(
+  virtualMachineBackupAttributesAttributes:
+    VirtualMachineBackupAttributesAttributes,
+): string {
+  return JSON.stringify(
+    VirtualMachineBackupAttributesAttributes$outboundSchema.parse(
+      virtualMachineBackupAttributesAttributes,
+    ),
+  );
+}
+export function virtualMachineBackupAttributesAttributesFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  VirtualMachineBackupAttributesAttributes,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      VirtualMachineBackupAttributesAttributes$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'VirtualMachineBackupAttributesAttributes' from JSON`,
+  );
+}
+
+/** @internal */
+export const VirtualMachineBackupAttributes$inboundSchema: z.ZodType<
+  VirtualMachineBackupAttributes,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string().optional(),
+  type: VirtualMachineBackupAttributesType$inboundSchema.optional(),
+  attributes: z.lazy(() =>
+    VirtualMachineBackupAttributesAttributes$inboundSchema
+  ).optional(),
+});
+/** @internal */
+export type VirtualMachineBackupAttributes$Outbound = {
+  id?: string | undefined;
+  type?: string | undefined;
+  attributes?: VirtualMachineBackupAttributesAttributes$Outbound | undefined;
+};
+
+/** @internal */
+export const VirtualMachineBackupAttributes$outboundSchema: z.ZodType<
+  VirtualMachineBackupAttributes$Outbound,
+  z.ZodTypeDef,
+  VirtualMachineBackupAttributes
+> = z.object({
+  id: z.string().optional(),
+  type: VirtualMachineBackupAttributesType$outboundSchema.optional(),
+  attributes: z.lazy(() =>
+    VirtualMachineBackupAttributesAttributes$outboundSchema
+  ).optional(),
+});
+
+export function virtualMachineBackupAttributesToJSON(
+  virtualMachineBackupAttributes: VirtualMachineBackupAttributes,
+): string {
+  return JSON.stringify(
+    VirtualMachineBackupAttributes$outboundSchema.parse(
+      virtualMachineBackupAttributes,
+    ),
+  );
+}
+export function virtualMachineBackupAttributesFromJSON(
+  jsonString: string,
+): SafeParseResult<VirtualMachineBackupAttributes, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VirtualMachineBackupAttributes$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VirtualMachineBackupAttributes' from JSON`,
+  );
+}

package/src/models/virtualmachinebackuppayload.ts

@@ -0,0 +1,179 @@
+/*
+ * 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";
+
+export const VirtualMachineBackupPayloadType = {
+  VirtualMachineBackups: "virtual_machine_backups",
+} as const;
+export type VirtualMachineBackupPayloadType = ClosedEnum<
+  typeof VirtualMachineBackupPayloadType
+>;
+
+export type VirtualMachineBackupPayloadAttributes = {
+  /**
+   * Virtual machine id to back up. Required on the top-level `POST /virtual_machine_backups`; taken from the path when nested under a VM.
+   */
+  virtualMachine?: string | undefined;
+};
+
+export type VirtualMachineBackupPayloadData = {
+  type?: VirtualMachineBackupPayloadType | undefined;
+  attributes?: VirtualMachineBackupPayloadAttributes | undefined;
+};
+
+export type VirtualMachineBackupPayload = {
+  data?: VirtualMachineBackupPayloadData | undefined;
+};
+
+/** @internal */
+export const VirtualMachineBackupPayloadType$inboundSchema: z.ZodNativeEnum<
+  typeof VirtualMachineBackupPayloadType
+> = z.nativeEnum(VirtualMachineBackupPayloadType);
+/** @internal */
+export const VirtualMachineBackupPayloadType$outboundSchema: z.ZodNativeEnum<
+  typeof VirtualMachineBackupPayloadType
+> = VirtualMachineBackupPayloadType$inboundSchema;
+
+/** @internal */
+export const VirtualMachineBackupPayloadAttributes$inboundSchema: z.ZodType<
+  VirtualMachineBackupPayloadAttributes,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  virtual_machine: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "virtual_machine": "virtualMachine",
+  });
+});
+/** @internal */
+export type VirtualMachineBackupPayloadAttributes$Outbound = {
+  virtual_machine?: string | undefined;
+};
+
+/** @internal */
+export const VirtualMachineBackupPayloadAttributes$outboundSchema: z.ZodType<
+  VirtualMachineBackupPayloadAttributes$Outbound,
+  z.ZodTypeDef,
+  VirtualMachineBackupPayloadAttributes
+> = z.object({
+  virtualMachine: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    virtualMachine: "virtual_machine",
+  });
+});
+
+export function virtualMachineBackupPayloadAttributesToJSON(
+  virtualMachineBackupPayloadAttributes: VirtualMachineBackupPayloadAttributes,
+): string {
+  return JSON.stringify(
+    VirtualMachineBackupPayloadAttributes$outboundSchema.parse(
+      virtualMachineBackupPayloadAttributes,
+    ),
+  );
+}
+export function virtualMachineBackupPayloadAttributesFromJSON(
+  jsonString: string,
+): SafeParseResult<VirtualMachineBackupPayloadAttributes, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      VirtualMachineBackupPayloadAttributes$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VirtualMachineBackupPayloadAttributes' from JSON`,
+  );
+}
+
+/** @internal */
+export const VirtualMachineBackupPayloadData$inboundSchema: z.ZodType<
+  VirtualMachineBackupPayloadData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: VirtualMachineBackupPayloadType$inboundSchema.optional(),
+  attributes: z.lazy(() => VirtualMachineBackupPayloadAttributes$inboundSchema)
+    .optional(),
+});
+/** @internal */
+export type VirtualMachineBackupPayloadData$Outbound = {
+  type?: string | undefined;
+  attributes?: VirtualMachineBackupPayloadAttributes$Outbound | undefined;
+};
+
+/** @internal */
+export const VirtualMachineBackupPayloadData$outboundSchema: z.ZodType<
+  VirtualMachineBackupPayloadData$Outbound,
+  z.ZodTypeDef,
+  VirtualMachineBackupPayloadData
+> = z.object({
+  type: VirtualMachineBackupPayloadType$outboundSchema.optional(),
+  attributes: z.lazy(() => VirtualMachineBackupPayloadAttributes$outboundSchema)
+    .optional(),
+});
+
+export function virtualMachineBackupPayloadDataToJSON(
+  virtualMachineBackupPayloadData: VirtualMachineBackupPayloadData,
+): string {
+  return JSON.stringify(
+    VirtualMachineBackupPayloadData$outboundSchema.parse(
+      virtualMachineBackupPayloadData,
+    ),
+  );
+}
+export function virtualMachineBackupPayloadDataFromJSON(
+  jsonString: string,
+): SafeParseResult<VirtualMachineBackupPayloadData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VirtualMachineBackupPayloadData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VirtualMachineBackupPayloadData' from JSON`,
+  );
+}
+
+/** @internal */
+export const VirtualMachineBackupPayload$inboundSchema: z.ZodType<
+  VirtualMachineBackupPayload,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.lazy(() => VirtualMachineBackupPayloadData$inboundSchema).optional(),
+});
+/** @internal */
+export type VirtualMachineBackupPayload$Outbound = {
+  data?: VirtualMachineBackupPayloadData$Outbound | undefined;
+};
+
+/** @internal */
+export const VirtualMachineBackupPayload$outboundSchema: z.ZodType<
+  VirtualMachineBackupPayload$Outbound,
+  z.ZodTypeDef,
+  VirtualMachineBackupPayload
+> = z.object({
+  data: z.lazy(() => VirtualMachineBackupPayloadData$outboundSchema).optional(),
+});
+
+export function virtualMachineBackupPayloadToJSON(
+  virtualMachineBackupPayload: VirtualMachineBackupPayload,
+): string {
+  return JSON.stringify(
+    VirtualMachineBackupPayload$outboundSchema.parse(
+      virtualMachineBackupPayload,
+    ),
+  );
+}
+export function virtualMachineBackupPayloadFromJSON(
+  jsonString: string,
+): SafeParseResult<VirtualMachineBackupPayload, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VirtualMachineBackupPayload$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VirtualMachineBackupPayload' from JSON`,
+  );
+}

package/src/models/virtualmachinebackups.ts

@@ -0,0 +1,96 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import {
+  VirtualMachineBackupAttributes,
+  VirtualMachineBackupAttributes$inboundSchema,
+  VirtualMachineBackupAttributes$Outbound,
+  VirtualMachineBackupAttributes$outboundSchema,
+} from "./virtualmachinebackupattributes.js";
+
+export type VirtualMachineBackupsMeta = {};
+
+export type VirtualMachineBackups = {
+  data?: Array<VirtualMachineBackupAttributes> | undefined;
+  meta?: VirtualMachineBackupsMeta | undefined;
+};
+
+/** @internal */
+export const VirtualMachineBackupsMeta$inboundSchema: z.ZodType<
+  VirtualMachineBackupsMeta,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+/** @internal */
+export type VirtualMachineBackupsMeta$Outbound = {};
+
+/** @internal */
+export const VirtualMachineBackupsMeta$outboundSchema: z.ZodType<
+  VirtualMachineBackupsMeta$Outbound,
+  z.ZodTypeDef,
+  VirtualMachineBackupsMeta
+> = z.object({});
+
+export function virtualMachineBackupsMetaToJSON(
+  virtualMachineBackupsMeta: VirtualMachineBackupsMeta,
+): string {
+  return JSON.stringify(
+    VirtualMachineBackupsMeta$outboundSchema.parse(virtualMachineBackupsMeta),
+  );
+}
+export function virtualMachineBackupsMetaFromJSON(
+  jsonString: string,
+): SafeParseResult<VirtualMachineBackupsMeta, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VirtualMachineBackupsMeta$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VirtualMachineBackupsMeta' from JSON`,
+  );
+}
+
+/** @internal */
+export const VirtualMachineBackups$inboundSchema: z.ZodType<
+  VirtualMachineBackups,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.array(VirtualMachineBackupAttributes$inboundSchema).optional(),
+  meta: z.lazy(() => VirtualMachineBackupsMeta$inboundSchema).optional(),
+});
+/** @internal */
+export type VirtualMachineBackups$Outbound = {
+  data?: Array<VirtualMachineBackupAttributes$Outbound> | undefined;
+  meta?: VirtualMachineBackupsMeta$Outbound | undefined;
+};
+
+/** @internal */
+export const VirtualMachineBackups$outboundSchema: z.ZodType<
+  VirtualMachineBackups$Outbound,
+  z.ZodTypeDef,
+  VirtualMachineBackups
+> = z.object({
+  data: z.array(VirtualMachineBackupAttributes$outboundSchema).optional(),
+  meta: z.lazy(() => VirtualMachineBackupsMeta$outboundSchema).optional(),
+});
+
+export function virtualMachineBackupsToJSON(
+  virtualMachineBackups: VirtualMachineBackups,
+): string {
+  return JSON.stringify(
+    VirtualMachineBackups$outboundSchema.parse(virtualMachineBackups),
+  );
+}
+export function virtualMachineBackupsFromJSON(
+  jsonString: string,
+): SafeParseResult<VirtualMachineBackups, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VirtualMachineBackups$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VirtualMachineBackups' from JSON`,
+  );
+}

package/src/models/virtualmachinepayload.ts

@@ -30,7 +30,7 @@ export type VirtualMachinePayloadAttributes = {
   sshKeys?: Array<string> | null | undefined;
   project?: string | undefined;
   /**
-   * The operating system slug for the Virtual Machine. If not specified, defaults to ubuntu-24-04 for CPU plans or ubuntu24_ml_in_a_box for GPU plans.
+   * The operating system slug for the Virtual Machine. If not specified, defaults to ubuntu_24_04_x64_lts for CPU plans or ubuntu24_ml_in_a_box for GPU plans.
    */
   operatingSystem?: string | null | undefined;
   /**
@@ -41,6 +41,10 @@ export type VirtualMachinePayloadAttributes = {
    * Array of tag IDs to assign to the VM.
    */
   tags?: Array<string> | null | undefined;
+  /**
+   * Site/region slug where the VM is provisioned (e.g. DAL, SAO). Defaults to DAL when omitted.
+   */
+  site?: string | null | undefined;
 };
 
 export type VirtualMachinePayloadData = {
@@ -103,6 +107,7 @@ export const VirtualMachinePayloadAttributes$inboundSchema: z.ZodType<
   operating_system: z.nullable(z.string()).optional(),
   user_data: z.nullable(z.union([z.number().int(), z.string()])).optional(),
   tags: z.nullable(z.array(z.string())).optional(),
+  site: z.nullable(z.string().default("DAL")),
 }).transform((v) => {
   return remap$(v, {
     "ssh_keys": "sshKeys",
@@ -119,6 +124,7 @@ export type VirtualMachinePayloadAttributes$Outbound = {
   operating_system?: string | null | undefined;
   user_data?: number | string | null | undefined;
   tags?: Array<string> | null | undefined;
+  site: string | null;
 };
 
 /** @internal */
@@ -134,6 +140,7 @@ export const VirtualMachinePayloadAttributes$outboundSchema: z.ZodType<
   operatingSystem: z.nullable(z.string()).optional(),
   userData: z.nullable(z.union([z.number().int(), z.string()])).optional(),
   tags: z.nullable(z.array(z.string())).optional(),
+  site: z.nullable(z.string().default("DAL")),
 }).transform((v) => {
   return remap$(v, {
     sshKeys: "ssh_keys",

package/src/models/virtualmachinerestore.ts

@@ -0,0 +1,96 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import {
+  VirtualMachineRestoreAttributes,
+  VirtualMachineRestoreAttributes$inboundSchema,
+  VirtualMachineRestoreAttributes$Outbound,
+  VirtualMachineRestoreAttributes$outboundSchema,
+} from "./virtualmachinerestoreattributes.js";
+
+export type VirtualMachineRestoreMeta = {};
+
+export type VirtualMachineRestore = {
+  data?: VirtualMachineRestoreAttributes | undefined;
+  meta?: VirtualMachineRestoreMeta | undefined;
+};
+
+/** @internal */
+export const VirtualMachineRestoreMeta$inboundSchema: z.ZodType<
+  VirtualMachineRestoreMeta,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+/** @internal */
+export type VirtualMachineRestoreMeta$Outbound = {};
+
+/** @internal */
+export const VirtualMachineRestoreMeta$outboundSchema: z.ZodType<
+  VirtualMachineRestoreMeta$Outbound,
+  z.ZodTypeDef,
+  VirtualMachineRestoreMeta
+> = z.object({});
+
+export function virtualMachineRestoreMetaToJSON(
+  virtualMachineRestoreMeta: VirtualMachineRestoreMeta,
+): string {
+  return JSON.stringify(
+    VirtualMachineRestoreMeta$outboundSchema.parse(virtualMachineRestoreMeta),
+  );
+}
+export function virtualMachineRestoreMetaFromJSON(
+  jsonString: string,
+): SafeParseResult<VirtualMachineRestoreMeta, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VirtualMachineRestoreMeta$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VirtualMachineRestoreMeta' from JSON`,
+  );
+}
+
+/** @internal */
+export const VirtualMachineRestore$inboundSchema: z.ZodType<
+  VirtualMachineRestore,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: VirtualMachineRestoreAttributes$inboundSchema.optional(),
+  meta: z.lazy(() => VirtualMachineRestoreMeta$inboundSchema).optional(),
+});
+/** @internal */
+export type VirtualMachineRestore$Outbound = {
+  data?: VirtualMachineRestoreAttributes$Outbound | undefined;
+  meta?: VirtualMachineRestoreMeta$Outbound | undefined;
+};
+
+/** @internal */
+export const VirtualMachineRestore$outboundSchema: z.ZodType<
+  VirtualMachineRestore$Outbound,
+  z.ZodTypeDef,
+  VirtualMachineRestore
+> = z.object({
+  data: VirtualMachineRestoreAttributes$outboundSchema.optional(),
+  meta: z.lazy(() => VirtualMachineRestoreMeta$outboundSchema).optional(),
+});
+
+export function virtualMachineRestoreToJSON(
+  virtualMachineRestore: VirtualMachineRestore,
+): string {
+  return JSON.stringify(
+    VirtualMachineRestore$outboundSchema.parse(virtualMachineRestore),
+  );
+}
+export function virtualMachineRestoreFromJSON(
+  jsonString: string,
+): SafeParseResult<VirtualMachineRestore, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VirtualMachineRestore$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VirtualMachineRestore' from JSON`,
+  );
+}