latitudesh-typescript-sdk 0.4.1 → 0.6.0

package/src/models/virtualmachineattributes.ts

@@ -128,6 +128,13 @@ export type VirtualMachineAttributesSpecs = {
   gpu?: string | null | undefined;
 };
 
+export type VirtualMachineAttributesTag = {
+  id?: string | undefined;
+  name?: string | undefined;
+  description?: string | null | undefined;
+  color?: string | null | undefined;
+};
+
 export type VirtualMachineAttributesAttributes = {
   name?: string | undefined;
   createdAt?: string | undefined;
@@ -141,10 +148,21 @@ export type VirtualMachineAttributesAttributes = {
    * SSH credentials for connecting to the virtual machine. Only available when the VM is running.
    */
   credentials?: VirtualMachineAttributesCredentials | null | undefined;
+  site?: string | null | undefined;
+  billing?: string | null | undefined;
+  /**
+   * Encoded ID of the user data record applied to this VM, if any
+   */
+  userData?: string | null | undefined;
   plan?: VirtualMachineAttributesPlan | undefined;
   specs?: VirtualMachineAttributesSpecs | undefined;
+  tags?: Array<VirtualMachineAttributesTag> | undefined;
   team?: TeamInclude | undefined;
   project?: ProjectInclude | undefined;
+  /**
+   * Opt-in extra field. Request via `extra_fields[virtual_machines]=pending_restart`.
+   */
+  pendingRestart?: boolean | undefined;
 };
 
 export type VirtualMachineAttributes = {
@@ -494,6 +512,56 @@ export function virtualMachineAttributesSpecsFromJSON(
   );
 }
 
+/** @internal */
+export const VirtualMachineAttributesTag$inboundSchema: z.ZodType<
+  VirtualMachineAttributesTag,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string().optional(),
+  name: z.string().optional(),
+  description: z.nullable(z.string()).optional(),
+  color: z.nullable(z.string()).optional(),
+});
+/** @internal */
+export type VirtualMachineAttributesTag$Outbound = {
+  id?: string | undefined;
+  name?: string | undefined;
+  description?: string | null | undefined;
+  color?: string | null | undefined;
+};
+
+/** @internal */
+export const VirtualMachineAttributesTag$outboundSchema: z.ZodType<
+  VirtualMachineAttributesTag$Outbound,
+  z.ZodTypeDef,
+  VirtualMachineAttributesTag
+> = z.object({
+  id: z.string().optional(),
+  name: z.string().optional(),
+  description: z.nullable(z.string()).optional(),
+  color: z.nullable(z.string()).optional(),
+});
+
+export function virtualMachineAttributesTagToJSON(
+  virtualMachineAttributesTag: VirtualMachineAttributesTag,
+): string {
+  return JSON.stringify(
+    VirtualMachineAttributesTag$outboundSchema.parse(
+      virtualMachineAttributesTag,
+    ),
+  );
+}
+export function virtualMachineAttributesTagFromJSON(
+  jsonString: string,
+): SafeParseResult<VirtualMachineAttributesTag, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VirtualMachineAttributesTag$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VirtualMachineAttributesTag' from JSON`,
+  );
+}
+
 /** @internal */
 export const VirtualMachineAttributesAttributes$inboundSchema: z.ZodType<
   VirtualMachineAttributesAttributes,
@@ -510,15 +578,23 @@ export const VirtualMachineAttributesAttributes$inboundSchema: z.ZodType<
   credentials: z.nullable(
     z.lazy(() => VirtualMachineAttributesCredentials$inboundSchema),
   ).optional(),
+  site: z.nullable(z.string()).optional(),
+  billing: z.nullable(z.string()).optional(),
+  user_data: z.nullable(z.string()).optional(),
   plan: z.lazy(() => VirtualMachineAttributesPlan$inboundSchema).optional(),
   specs: z.lazy(() => VirtualMachineAttributesSpecs$inboundSchema).optional(),
+  tags: z.array(z.lazy(() => VirtualMachineAttributesTag$inboundSchema))
+    .optional(),
   team: TeamInclude$inboundSchema.optional(),
   project: ProjectInclude$inboundSchema.optional(),
+  pending_restart: z.boolean().optional(),
 }).transform((v) => {
   return remap$(v, {
     "created_at": "createdAt",
     "primary_ipv4": "primaryIpv4",
     "operating_system": "operatingSystem",
+    "user_data": "userData",
+    "pending_restart": "pendingRestart",
   });
 });
 /** @internal */
@@ -532,10 +608,15 @@ export type VirtualMachineAttributesAttributes$Outbound = {
     | null
     | undefined;
   credentials?: VirtualMachineAttributesCredentials$Outbound | null | undefined;
+  site?: string | null | undefined;
+  billing?: string | null | undefined;
+  user_data?: string | null | undefined;
   plan?: VirtualMachineAttributesPlan$Outbound | undefined;
   specs?: VirtualMachineAttributesSpecs$Outbound | undefined;
+  tags?: Array<VirtualMachineAttributesTag$Outbound> | undefined;
   team?: TeamInclude$Outbound | undefined;
   project?: ProjectInclude$Outbound | undefined;
+  pending_restart?: boolean | undefined;
 };
 
 /** @internal */
@@ -554,15 +635,23 @@ export const VirtualMachineAttributesAttributes$outboundSchema: z.ZodType<
   credentials: z.nullable(
     z.lazy(() => VirtualMachineAttributesCredentials$outboundSchema),
   ).optional(),
+  site: z.nullable(z.string()).optional(),
+  billing: z.nullable(z.string()).optional(),
+  userData: z.nullable(z.string()).optional(),
   plan: z.lazy(() => VirtualMachineAttributesPlan$outboundSchema).optional(),
   specs: z.lazy(() => VirtualMachineAttributesSpecs$outboundSchema).optional(),
+  tags: z.array(z.lazy(() => VirtualMachineAttributesTag$outboundSchema))
+    .optional(),
   team: TeamInclude$outboundSchema.optional(),
   project: ProjectInclude$outboundSchema.optional(),
+  pendingRestart: z.boolean().optional(),
 }).transform((v) => {
   return remap$(v, {
     createdAt: "created_at",
     primaryIpv4: "primary_ipv4",
     operatingSystem: "operating_system",
+    userData: "user_data",
+    pendingRestart: "pending_restart",
   });
 });
 

package/src/models/virtualmachinemetrics.ts

@@ -0,0 +1,175 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+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 Metric = {
+  Cpu: "cpu",
+  Memory: "memory",
+  Network: "network",
+  Disk: "disk",
+} as const;
+export type Metric = ClosedEnum<typeof Metric>;
+
+export const Range = {
+  Fivem: "5m",
+  Fifteenm: "15m",
+  Oneh: "1h",
+  TwentyFourh: "24h",
+} as const;
+export type Range = ClosedEnum<typeof Range>;
+
+/**
+ * Unit applied to every point value
+ */
+export const VirtualMachineMetricsUnit = {
+  Percent: "percent",
+  BytesPerSecond: "bytes_per_second",
+} as const;
+/**
+ * Unit applied to every point value
+ */
+export type VirtualMachineMetricsUnit = ClosedEnum<
+  typeof VirtualMachineMetricsUnit
+>;
+
+export type Point = {
+  /**
+   * ISO 8601 UTC timestamp (seconds precision)
+   */
+  timestamp?: Date | undefined;
+  /**
+   * Sampled value, rounded to 2 decimal places
+   */
+  value?: number | undefined;
+};
+
+export type VirtualMachineMetrics = {
+  metric?: Metric | undefined;
+  range?: Range | undefined;
+  /**
+   * Sampling interval between adjacent points (e.g. "15s", "1m")
+   */
+  step?: string | undefined;
+  /**
+   * Unit applied to every point value
+   */
+  unit?: VirtualMachineMetricsUnit | undefined;
+  points?: Array<Point> | undefined;
+};
+
+/** @internal */
+export const Metric$inboundSchema: z.ZodNativeEnum<typeof Metric> = z
+  .nativeEnum(Metric);
+/** @internal */
+export const Metric$outboundSchema: z.ZodNativeEnum<typeof Metric> =
+  Metric$inboundSchema;
+
+/** @internal */
+export const Range$inboundSchema: z.ZodNativeEnum<typeof Range> = z.nativeEnum(
+  Range,
+);
+/** @internal */
+export const Range$outboundSchema: z.ZodNativeEnum<typeof Range> =
+  Range$inboundSchema;
+
+/** @internal */
+export const VirtualMachineMetricsUnit$inboundSchema: z.ZodNativeEnum<
+  typeof VirtualMachineMetricsUnit
+> = z.nativeEnum(VirtualMachineMetricsUnit);
+/** @internal */
+export const VirtualMachineMetricsUnit$outboundSchema: z.ZodNativeEnum<
+  typeof VirtualMachineMetricsUnit
+> = VirtualMachineMetricsUnit$inboundSchema;
+
+/** @internal */
+export const Point$inboundSchema: z.ZodType<Point, z.ZodTypeDef, unknown> = z
+  .object({
+    timestamp: z.string().datetime({ offset: true }).transform(v => new Date(v))
+      .optional(),
+    value: z.number().optional(),
+  });
+/** @internal */
+export type Point$Outbound = {
+  timestamp?: string | undefined;
+  value?: number | undefined;
+};
+
+/** @internal */
+export const Point$outboundSchema: z.ZodType<
+  Point$Outbound,
+  z.ZodTypeDef,
+  Point
+> = z.object({
+  timestamp: z.date().transform(v => v.toISOString()).optional(),
+  value: z.number().optional(),
+});
+
+export function pointToJSON(point: Point): string {
+  return JSON.stringify(Point$outboundSchema.parse(point));
+}
+export function pointFromJSON(
+  jsonString: string,
+): SafeParseResult<Point, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Point$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Point' from JSON`,
+  );
+}
+
+/** @internal */
+export const VirtualMachineMetrics$inboundSchema: z.ZodType<
+  VirtualMachineMetrics,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  metric: Metric$inboundSchema.optional(),
+  range: Range$inboundSchema.optional(),
+  step: z.string().optional(),
+  unit: VirtualMachineMetricsUnit$inboundSchema.optional(),
+  points: z.array(z.lazy(() => Point$inboundSchema)).optional(),
+});
+/** @internal */
+export type VirtualMachineMetrics$Outbound = {
+  metric?: string | undefined;
+  range?: string | undefined;
+  step?: string | undefined;
+  unit?: string | undefined;
+  points?: Array<Point$Outbound> | undefined;
+};
+
+/** @internal */
+export const VirtualMachineMetrics$outboundSchema: z.ZodType<
+  VirtualMachineMetrics$Outbound,
+  z.ZodTypeDef,
+  VirtualMachineMetrics
+> = z.object({
+  metric: Metric$outboundSchema.optional(),
+  range: Range$outboundSchema.optional(),
+  step: z.string().optional(),
+  unit: VirtualMachineMetricsUnit$outboundSchema.optional(),
+  points: z.array(z.lazy(() => Point$outboundSchema)).optional(),
+});
+
+export function virtualMachineMetricsToJSON(
+  virtualMachineMetrics: VirtualMachineMetrics,
+): string {
+  return JSON.stringify(
+    VirtualMachineMetrics$outboundSchema.parse(virtualMachineMetrics),
+  );
+}
+export function virtualMachineMetricsFromJSON(
+  jsonString: string,
+): SafeParseResult<VirtualMachineMetrics, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VirtualMachineMetrics$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VirtualMachineMetrics' from JSON`,
+  );
+}

package/src/models/virtualmachinenetworkattachmentcreatepayload.ts

@@ -0,0 +1,210 @@
+/*
+ * 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 VirtualMachineNetworkAttachmentCreatePayloadType = {
+  VirtualMachineNetworkAttachments: "virtual_machine_network_attachments",
+} as const;
+export type VirtualMachineNetworkAttachmentCreatePayloadType = ClosedEnum<
+  typeof VirtualMachineNetworkAttachmentCreatePayloadType
+>;
+
+export type VirtualMachineNetworkAttachmentCreatePayloadAttributes = {
+  /**
+   * VLAN id_hash to attach (e.g. vlan_abc123).
+   */
+  virtualNetworkId: string;
+};
+
+export type VirtualMachineNetworkAttachmentCreatePayloadData = {
+  type: VirtualMachineNetworkAttachmentCreatePayloadType;
+  attributes: VirtualMachineNetworkAttachmentCreatePayloadAttributes;
+};
+
+export type VirtualMachineNetworkAttachmentCreatePayload = {
+  data: VirtualMachineNetworkAttachmentCreatePayloadData;
+};
+
+/** @internal */
+export const VirtualMachineNetworkAttachmentCreatePayloadType$inboundSchema:
+  z.ZodNativeEnum<typeof VirtualMachineNetworkAttachmentCreatePayloadType> = z
+    .nativeEnum(VirtualMachineNetworkAttachmentCreatePayloadType);
+/** @internal */
+export const VirtualMachineNetworkAttachmentCreatePayloadType$outboundSchema:
+  z.ZodNativeEnum<typeof VirtualMachineNetworkAttachmentCreatePayloadType> =
+    VirtualMachineNetworkAttachmentCreatePayloadType$inboundSchema;
+
+/** @internal */
+export const VirtualMachineNetworkAttachmentCreatePayloadAttributes$inboundSchema:
+  z.ZodType<
+    VirtualMachineNetworkAttachmentCreatePayloadAttributes,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    virtual_network_id: z.string(),
+  }).transform((v) => {
+    return remap$(v, {
+      "virtual_network_id": "virtualNetworkId",
+    });
+  });
+/** @internal */
+export type VirtualMachineNetworkAttachmentCreatePayloadAttributes$Outbound = {
+  virtual_network_id: string;
+};
+
+/** @internal */
+export const VirtualMachineNetworkAttachmentCreatePayloadAttributes$outboundSchema:
+  z.ZodType<
+    VirtualMachineNetworkAttachmentCreatePayloadAttributes$Outbound,
+    z.ZodTypeDef,
+    VirtualMachineNetworkAttachmentCreatePayloadAttributes
+  > = z.object({
+    virtualNetworkId: z.string(),
+  }).transform((v) => {
+    return remap$(v, {
+      virtualNetworkId: "virtual_network_id",
+    });
+  });
+
+export function virtualMachineNetworkAttachmentCreatePayloadAttributesToJSON(
+  virtualMachineNetworkAttachmentCreatePayloadAttributes:
+    VirtualMachineNetworkAttachmentCreatePayloadAttributes,
+): string {
+  return JSON.stringify(
+    VirtualMachineNetworkAttachmentCreatePayloadAttributes$outboundSchema.parse(
+      virtualMachineNetworkAttachmentCreatePayloadAttributes,
+    ),
+  );
+}
+export function virtualMachineNetworkAttachmentCreatePayloadAttributesFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  VirtualMachineNetworkAttachmentCreatePayloadAttributes,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      VirtualMachineNetworkAttachmentCreatePayloadAttributes$inboundSchema
+        .parse(JSON.parse(x)),
+    `Failed to parse 'VirtualMachineNetworkAttachmentCreatePayloadAttributes' from JSON`,
+  );
+}
+
+/** @internal */
+export const VirtualMachineNetworkAttachmentCreatePayloadData$inboundSchema:
+  z.ZodType<
+    VirtualMachineNetworkAttachmentCreatePayloadData,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    type: VirtualMachineNetworkAttachmentCreatePayloadType$inboundSchema,
+    attributes: z.lazy(() =>
+      VirtualMachineNetworkAttachmentCreatePayloadAttributes$inboundSchema
+    ),
+  });
+/** @internal */
+export type VirtualMachineNetworkAttachmentCreatePayloadData$Outbound = {
+  type: string;
+  attributes: VirtualMachineNetworkAttachmentCreatePayloadAttributes$Outbound;
+};
+
+/** @internal */
+export const VirtualMachineNetworkAttachmentCreatePayloadData$outboundSchema:
+  z.ZodType<
+    VirtualMachineNetworkAttachmentCreatePayloadData$Outbound,
+    z.ZodTypeDef,
+    VirtualMachineNetworkAttachmentCreatePayloadData
+  > = z.object({
+    type: VirtualMachineNetworkAttachmentCreatePayloadType$outboundSchema,
+    attributes: z.lazy(() =>
+      VirtualMachineNetworkAttachmentCreatePayloadAttributes$outboundSchema
+    ),
+  });
+
+export function virtualMachineNetworkAttachmentCreatePayloadDataToJSON(
+  virtualMachineNetworkAttachmentCreatePayloadData:
+    VirtualMachineNetworkAttachmentCreatePayloadData,
+): string {
+  return JSON.stringify(
+    VirtualMachineNetworkAttachmentCreatePayloadData$outboundSchema.parse(
+      virtualMachineNetworkAttachmentCreatePayloadData,
+    ),
+  );
+}
+export function virtualMachineNetworkAttachmentCreatePayloadDataFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  VirtualMachineNetworkAttachmentCreatePayloadData,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      VirtualMachineNetworkAttachmentCreatePayloadData$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'VirtualMachineNetworkAttachmentCreatePayloadData' from JSON`,
+  );
+}
+
+/** @internal */
+export const VirtualMachineNetworkAttachmentCreatePayload$inboundSchema:
+  z.ZodType<
+    VirtualMachineNetworkAttachmentCreatePayload,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    data: z.lazy(() =>
+      VirtualMachineNetworkAttachmentCreatePayloadData$inboundSchema
+    ),
+  });
+/** @internal */
+export type VirtualMachineNetworkAttachmentCreatePayload$Outbound = {
+  data: VirtualMachineNetworkAttachmentCreatePayloadData$Outbound;
+};
+
+/** @internal */
+export const VirtualMachineNetworkAttachmentCreatePayload$outboundSchema:
+  z.ZodType<
+    VirtualMachineNetworkAttachmentCreatePayload$Outbound,
+    z.ZodTypeDef,
+    VirtualMachineNetworkAttachmentCreatePayload
+  > = z.object({
+    data: z.lazy(() =>
+      VirtualMachineNetworkAttachmentCreatePayloadData$outboundSchema
+    ),
+  });
+
+export function virtualMachineNetworkAttachmentCreatePayloadToJSON(
+  virtualMachineNetworkAttachmentCreatePayload:
+    VirtualMachineNetworkAttachmentCreatePayload,
+): string {
+  return JSON.stringify(
+    VirtualMachineNetworkAttachmentCreatePayload$outboundSchema.parse(
+      virtualMachineNetworkAttachmentCreatePayload,
+    ),
+  );
+}
+export function virtualMachineNetworkAttachmentCreatePayloadFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  VirtualMachineNetworkAttachmentCreatePayload,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      VirtualMachineNetworkAttachmentCreatePayload$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'VirtualMachineNetworkAttachmentCreatePayload' from JSON`,
+  );
+}