latitudesh-typescript-sdk 0.8.0 → 0.8.1

package/src/models/project.ts

@@ -5,7 +5,8 @@
 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 * as openEnums from "../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import {
@@ -15,6 +16,13 @@ import {
   TeamInclude$outboundSchema,
 } from "./teaminclude.js";
 
+export const ProjectType = {
+  Projects: "projects",
+} as const;
+export type ProjectType = ClosedEnum<typeof ProjectType>;
+
+export type ProjectTag = {};
+
 export const BillingType = {
   Yearly: "Yearly",
   Monthly: "Monthly",
@@ -22,22 +30,26 @@ export const BillingType = {
   Normal: "Normal",
   Custom: "Custom",
 } as const;
-export type BillingType = ClosedEnum<typeof BillingType>;
+export type BillingType = OpenEnum<typeof BillingType>;
 
 export const BillingMethod = {
   Normal: "Normal",
   NinetyFivethPercentile: "95th percentile",
 } as const;
-export type BillingMethod = ClosedEnum<typeof BillingMethod>;
+export type BillingMethod = OpenEnum<typeof BillingMethod>;
 
 export const Environment = {
   Development: "Development",
   Staging: "Staging",
   Production: "Production",
 } as const;
-export type Environment = ClosedEnum<typeof Environment>;
+export type Environment = OpenEnum<typeof Environment>;
 
 export type ProjectStats = {
+  /**
+   * The number of database servers assigned to the project
+   */
+  databases?: number | undefined;
   /**
    * The number of IP addresses assigned to the project
    */
@@ -51,9 +63,13 @@ export type ProjectStats = {
    */
   servers?: number | undefined;
   /**
-   * The number of containers assigned to the project
+   * The number of storages assigned to the project
    */
-  containers?: number | undefined;
+  storages?: number | undefined;
+  /**
+   * The number of active virtual machines assigned to the project
+   */
+  virtualMachines?: number | undefined;
   /**
    * The number of VLANs assigned to the project
    */
@@ -67,6 +83,10 @@ export type ProjectBilling = {
 };
 
 export type ProjectAttributes = {
+  /**
+   * The tags assigned to the project
+   */
+  tags?: Array<ProjectTag> | undefined;
   /**
    * The project name
    */
@@ -82,7 +102,15 @@ export type ProjectAttributes = {
   billingType?: BillingType | null | undefined;
   billingMethod?: BillingMethod | null | undefined;
   cost?: string | null | undefined;
+  /**
+   * Whether bandwidth quota alerts are enabled for the project
+   */
+  bandwidthAlert?: boolean | null | undefined;
   environment?: Environment | null | undefined;
+  /**
+   * The project provisioning model, either on_demand (pay-as-you-go, hourly or monthly billing) or reserved (annual contract with yearly billing). Defaults to on_demand.
+   */
+  provisioningType?: string | null | undefined;
   stats?: ProjectStats | undefined;
   billing?: ProjectBilling | undefined;
   team?: TeamInclude | undefined;
@@ -95,31 +123,84 @@ export type Project = {
    * The project ID
    */
   id?: string | undefined;
+  type?: ProjectType | undefined;
   attributes?: ProjectAttributes | undefined;
 };
 
 /** @internal */
-export const BillingType$inboundSchema: z.ZodNativeEnum<typeof BillingType> = z
-  .nativeEnum(BillingType);
+export const ProjectType$inboundSchema: z.ZodNativeEnum<typeof ProjectType> = z
+  .nativeEnum(ProjectType);
 /** @internal */
-export const BillingType$outboundSchema: z.ZodNativeEnum<typeof BillingType> =
-  BillingType$inboundSchema;
+export const ProjectType$outboundSchema: z.ZodNativeEnum<typeof ProjectType> =
+  ProjectType$inboundSchema;
 
 /** @internal */
-export const BillingMethod$inboundSchema: z.ZodNativeEnum<
-  typeof BillingMethod
-> = z.nativeEnum(BillingMethod);
+export const ProjectTag$inboundSchema: z.ZodType<
+  ProjectTag,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
 /** @internal */
-export const BillingMethod$outboundSchema: z.ZodNativeEnum<
-  typeof BillingMethod
-> = BillingMethod$inboundSchema;
+export type ProjectTag$Outbound = {};
 
 /** @internal */
-export const Environment$inboundSchema: z.ZodNativeEnum<typeof Environment> = z
-  .nativeEnum(Environment);
+export const ProjectTag$outboundSchema: z.ZodType<
+  ProjectTag$Outbound,
+  z.ZodTypeDef,
+  ProjectTag
+> = z.object({});
+
+export function projectTagToJSON(projectTag: ProjectTag): string {
+  return JSON.stringify(ProjectTag$outboundSchema.parse(projectTag));
+}
+export function projectTagFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectTag, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProjectTag$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectTag' from JSON`,
+  );
+}
+
+/** @internal */
+export const BillingType$inboundSchema: z.ZodType<
+  BillingType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(BillingType);
+/** @internal */
+export const BillingType$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  BillingType
+> = openEnums.outboundSchema(BillingType);
+
+/** @internal */
+export const BillingMethod$inboundSchema: z.ZodType<
+  BillingMethod,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(BillingMethod);
+/** @internal */
+export const BillingMethod$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  BillingMethod
+> = openEnums.outboundSchema(BillingMethod);
+
 /** @internal */
-export const Environment$outboundSchema: z.ZodNativeEnum<typeof Environment> =
-  Environment$inboundSchema;
+export const Environment$inboundSchema: z.ZodType<
+  Environment,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(Environment);
+/** @internal */
+export const Environment$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  Environment
+> = openEnums.outboundSchema(Environment);
 
 /** @internal */
 export const ProjectStats$inboundSchema: z.ZodType<
@@ -127,22 +208,27 @@ export const ProjectStats$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
+  databases: z.number().optional(),
   ip_addresses: z.number().optional(),
   prefixes: z.number().optional(),
   servers: z.number().optional(),
-  containers: z.number().optional(),
+  storages: z.number().optional(),
+  virtual_machines: z.number().optional(),
   vlans: z.number().optional(),
 }).transform((v) => {
   return remap$(v, {
     "ip_addresses": "ipAddresses",
+    "virtual_machines": "virtualMachines",
   });
 });
 /** @internal */
 export type ProjectStats$Outbound = {
+  databases?: number | undefined;
   ip_addresses?: number | undefined;
   prefixes?: number | undefined;
   servers?: number | undefined;
-  containers?: number | undefined;
+  storages?: number | undefined;
+  virtual_machines?: number | undefined;
   vlans?: number | undefined;
 };
 
@@ -152,14 +238,17 @@ export const ProjectStats$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ProjectStats
 > = z.object({
+  databases: z.number().optional(),
   ipAddresses: z.number().optional(),
   prefixes: z.number().optional(),
   servers: z.number().optional(),
-  containers: z.number().optional(),
+  storages: z.number().optional(),
+  virtualMachines: z.number().optional(),
   vlans: z.number().optional(),
 }).transform((v) => {
   return remap$(v, {
     ipAddresses: "ip_addresses",
+    virtualMachines: "virtual_machines",
   });
 });
 
@@ -231,13 +320,16 @@ export const ProjectAttributes$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
+  tags: z.array(z.lazy(() => ProjectTag$inboundSchema)).optional(),
   name: z.string().optional(),
   slug: z.string().optional(),
   description: z.nullable(z.string()).optional(),
   billing_type: z.nullable(BillingType$inboundSchema).optional(),
   billing_method: z.nullable(BillingMethod$inboundSchema).optional(),
   cost: z.nullable(z.string()).optional(),
+  bandwidth_alert: z.nullable(z.boolean()).optional(),
   environment: z.nullable(Environment$inboundSchema).optional(),
+  provisioning_type: z.nullable(z.string()).optional(),
   stats: z.lazy(() => ProjectStats$inboundSchema).optional(),
   billing: z.lazy(() => ProjectBilling$inboundSchema).optional(),
   team: TeamInclude$inboundSchema.optional(),
@@ -247,19 +339,24 @@ export const ProjectAttributes$inboundSchema: z.ZodType<
   return remap$(v, {
     "billing_type": "billingType",
     "billing_method": "billingMethod",
+    "bandwidth_alert": "bandwidthAlert",
+    "provisioning_type": "provisioningType",
     "created_at": "createdAt",
     "updated_at": "updatedAt",
   });
 });
 /** @internal */
 export type ProjectAttributes$Outbound = {
+  tags?: Array<ProjectTag$Outbound> | undefined;
   name?: string | undefined;
   slug?: string | undefined;
   description?: string | null | undefined;
   billing_type?: string | null | undefined;
   billing_method?: string | null | undefined;
   cost?: string | null | undefined;
+  bandwidth_alert?: boolean | null | undefined;
   environment?: string | null | undefined;
+  provisioning_type?: string | null | undefined;
   stats?: ProjectStats$Outbound | undefined;
   billing?: ProjectBilling$Outbound | undefined;
   team?: TeamInclude$Outbound | undefined;
@@ -273,13 +370,16 @@ export const ProjectAttributes$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ProjectAttributes
 > = z.object({
+  tags: z.array(z.lazy(() => ProjectTag$outboundSchema)).optional(),
   name: z.string().optional(),
   slug: z.string().optional(),
   description: z.nullable(z.string()).optional(),
   billingType: z.nullable(BillingType$outboundSchema).optional(),
   billingMethod: z.nullable(BillingMethod$outboundSchema).optional(),
   cost: z.nullable(z.string()).optional(),
+  bandwidthAlert: z.nullable(z.boolean()).optional(),
   environment: z.nullable(Environment$outboundSchema).optional(),
+  provisioningType: z.nullable(z.string()).optional(),
   stats: z.lazy(() => ProjectStats$outboundSchema).optional(),
   billing: z.lazy(() => ProjectBilling$outboundSchema).optional(),
   team: TeamInclude$outboundSchema.optional(),
@@ -289,6 +389,8 @@ export const ProjectAttributes$outboundSchema: z.ZodType<
   return remap$(v, {
     billingType: "billing_type",
     billingMethod: "billing_method",
+    bandwidthAlert: "bandwidth_alert",
+    provisioningType: "provisioning_type",
     createdAt: "created_at",
     updatedAt: "updated_at",
   });
@@ -315,11 +417,13 @@ export function projectAttributesFromJSON(
 export const Project$inboundSchema: z.ZodType<Project, z.ZodTypeDef, unknown> =
   z.object({
     id: z.string().optional(),
+    type: ProjectType$inboundSchema.optional(),
     attributes: z.lazy(() => ProjectAttributes$inboundSchema).optional(),
   });
 /** @internal */
 export type Project$Outbound = {
   id?: string | undefined;
+  type?: string | undefined;
   attributes?: ProjectAttributes$Outbound | undefined;
 };
 
@@ -330,6 +434,7 @@ export const Project$outboundSchema: z.ZodType<
   Project
 > = z.object({
   id: z.string().optional(),
+  type: ProjectType$outboundSchema.optional(),
   attributes: z.lazy(() => ProjectAttributes$outboundSchema).optional(),
 });
 

package/src/models/projectinclude.ts

@@ -15,9 +15,12 @@ export type ProjectIncludeBilling = {
 };
 
 export type ProjectIncludeStats = {
+  databases?: number | undefined;
   ipAddresses?: number | undefined;
   prefixes?: number | undefined;
   servers?: number | undefined;
+  storages?: number | undefined;
+  virtualMachines?: number | undefined;
   vlans?: number | undefined;
 };
 
@@ -94,20 +97,27 @@ export const ProjectIncludeStats$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
+  databases: z.number().int().optional(),
   ip_addresses: z.number().int().optional(),
   prefixes: z.number().int().optional(),
   servers: z.number().int().optional(),
+  storages: z.number().int().optional(),
+  virtual_machines: z.number().int().optional(),
   vlans: z.number().int().optional(),
 }).transform((v) => {
   return remap$(v, {
     "ip_addresses": "ipAddresses",
+    "virtual_machines": "virtualMachines",
   });
 });
 /** @internal */
 export type ProjectIncludeStats$Outbound = {
+  databases?: number | undefined;
   ip_addresses?: number | undefined;
   prefixes?: number | undefined;
   servers?: number | undefined;
+  storages?: number | undefined;
+  virtual_machines?: number | undefined;
   vlans?: number | undefined;
 };
 
@@ -117,13 +127,17 @@ export const ProjectIncludeStats$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ProjectIncludeStats
 > = z.object({
+  databases: z.number().int().optional(),
   ipAddresses: z.number().int().optional(),
   prefixes: z.number().int().optional(),
   servers: z.number().int().optional(),
+  storages: z.number().int().optional(),
+  virtualMachines: z.number().int().optional(),
   vlans: z.number().int().optional(),
 }).transform((v) => {
   return remap$(v, {
     ipAddresses: "ip_addresses",
+    virtualMachines: "virtual_machines",
   });
 });
 

package/src/models/virtualmachineattributes.ts

@@ -28,18 +28,6 @@ export type VirtualMachineAttributesType = ClosedEnum<
   typeof VirtualMachineAttributesType
 >;
 
-export const VirtualMachineAttributesStatus = {
-  Running: "Running",
-  ConfiguringNetwork: "Configuring network",
-  Starting: "Starting",
-  Scheduling: "Scheduling",
-  Scheduled: "Scheduled",
-  Destroying: "Destroying",
-} as const;
-export type VirtualMachineAttributesStatus = ClosedEnum<
-  typeof VirtualMachineAttributesStatus
->;
-
 /**
  * Features supported by this operating system
  */
@@ -56,6 +44,14 @@ export type VirtualMachineAttributesFeatures = {
    * Whether user data is supported
    */
   userData?: boolean | undefined;
+  /**
+   * Whether rescue mode is supported
+   */
+  rescue?: boolean | undefined;
+  /**
+   * Whether workflow is supported
+   */
+  workflow?: boolean | undefined;
 };
 
 /**
@@ -138,7 +134,10 @@ export type VirtualMachineAttributesTag = {
 export type VirtualMachineAttributesAttributes = {
   name?: string | undefined;
   createdAt?: string | undefined;
-  status?: VirtualMachineAttributesStatus | undefined;
+  /**
+   * Current lifecycle status of the VM, derived from the underlying KubeVirt phase/printable status and capitalized. This is an open set that may grow over time — do not treat it as a closed enum. Known values include: Running, Starting, Stopped, Stopping, Failed, Off, Error, Rebooting, Deleting, Destroying, Configuring network, Scheduling, Scheduled, Provisioning.
+   */
+  status?: string | undefined;
   primaryIpv4?: string | null | undefined;
   /**
    * The operating system installed on the virtual machine
@@ -180,15 +179,6 @@ export const VirtualMachineAttributesType$outboundSchema: z.ZodNativeEnum<
   typeof VirtualMachineAttributesType
 > = VirtualMachineAttributesType$inboundSchema;
 
-/** @internal */
-export const VirtualMachineAttributesStatus$inboundSchema: z.ZodNativeEnum<
-  typeof VirtualMachineAttributesStatus
-> = z.nativeEnum(VirtualMachineAttributesStatus);
-/** @internal */
-export const VirtualMachineAttributesStatus$outboundSchema: z.ZodNativeEnum<
-  typeof VirtualMachineAttributesStatus
-> = VirtualMachineAttributesStatus$inboundSchema;
-
 /** @internal */
 export const VirtualMachineAttributesFeatures$inboundSchema: z.ZodType<
   VirtualMachineAttributesFeatures,
@@ -198,6 +188,8 @@ export const VirtualMachineAttributesFeatures$inboundSchema: z.ZodType<
   raid: z.boolean().optional(),
   ssh_keys: z.boolean().optional(),
   user_data: z.boolean().optional(),
+  rescue: z.boolean().optional(),
+  workflow: z.boolean().optional(),
 }).transform((v) => {
   return remap$(v, {
     "ssh_keys": "sshKeys",
@@ -209,6 +201,8 @@ export type VirtualMachineAttributesFeatures$Outbound = {
   raid?: boolean | undefined;
   ssh_keys?: boolean | undefined;
   user_data?: boolean | undefined;
+  rescue?: boolean | undefined;
+  workflow?: boolean | undefined;
 };
 
 /** @internal */
@@ -220,6 +214,8 @@ export const VirtualMachineAttributesFeatures$outboundSchema: z.ZodType<
   raid: z.boolean().optional(),
   sshKeys: z.boolean().optional(),
   userData: z.boolean().optional(),
+  rescue: z.boolean().optional(),
+  workflow: z.boolean().optional(),
 }).transform((v) => {
   return remap$(v, {
     sshKeys: "ssh_keys",
@@ -570,7 +566,7 @@ export const VirtualMachineAttributesAttributes$inboundSchema: z.ZodType<
 > = z.object({
   name: z.string().optional(),
   created_at: z.string().optional(),
-  status: VirtualMachineAttributesStatus$inboundSchema.optional(),
+  status: z.string().optional(),
   primary_ipv4: z.nullable(z.string()).optional(),
   operating_system: z.nullable(
     z.lazy(() => VirtualMachineAttributesOperatingSystem$inboundSchema),
@@ -627,7 +623,7 @@ export const VirtualMachineAttributesAttributes$outboundSchema: z.ZodType<
 > = z.object({
   name: z.string().optional(),
   createdAt: z.string().optional(),
-  status: VirtualMachineAttributesStatus$outboundSchema.optional(),
+  status: z.string().optional(),
   primaryIpv4: z.nullable(z.string()).optional(),
   operatingSystem: z.nullable(
     z.lazy(() => VirtualMachineAttributesOperatingSystem$outboundSchema),

package/src/models/virtualmachines.ts

@@ -6,6 +6,12 @@ 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 {
+  PaginationMeta,
+  PaginationMeta$inboundSchema,
+  PaginationMeta$Outbound,
+  PaginationMeta$outboundSchema,
+} from "./paginationmeta.js";
 import {
   VirtualMachineAttributes,
   VirtualMachineAttributes$inboundSchema,
@@ -13,46 +19,11 @@ import {
   VirtualMachineAttributes$outboundSchema,
 } from "./virtualmachineattributes.js";
 
-export type VirtualMachinesMeta = {};
-
 export type VirtualMachines = {
   data?: Array<VirtualMachineAttributes> | undefined;
-  meta?: VirtualMachinesMeta | undefined;
+  meta?: PaginationMeta | undefined;
 };
 
-/** @internal */
-export const VirtualMachinesMeta$inboundSchema: z.ZodType<
-  VirtualMachinesMeta,
-  z.ZodTypeDef,
-  unknown
-> = z.object({});
-/** @internal */
-export type VirtualMachinesMeta$Outbound = {};
-
-/** @internal */
-export const VirtualMachinesMeta$outboundSchema: z.ZodType<
-  VirtualMachinesMeta$Outbound,
-  z.ZodTypeDef,
-  VirtualMachinesMeta
-> = z.object({});
-
-export function virtualMachinesMetaToJSON(
-  virtualMachinesMeta: VirtualMachinesMeta,
-): string {
-  return JSON.stringify(
-    VirtualMachinesMeta$outboundSchema.parse(virtualMachinesMeta),
-  );
-}
-export function virtualMachinesMetaFromJSON(
-  jsonString: string,
-): SafeParseResult<VirtualMachinesMeta, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => VirtualMachinesMeta$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'VirtualMachinesMeta' from JSON`,
-  );
-}
-
 /** @internal */
 export const VirtualMachines$inboundSchema: z.ZodType<
   VirtualMachines,
@@ -60,12 +31,12 @@ export const VirtualMachines$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   data: z.array(VirtualMachineAttributes$inboundSchema).optional(),
-  meta: z.lazy(() => VirtualMachinesMeta$inboundSchema).optional(),
+  meta: PaginationMeta$inboundSchema.optional(),
 });
 /** @internal */
 export type VirtualMachines$Outbound = {
   data?: Array<VirtualMachineAttributes$Outbound> | undefined;
-  meta?: VirtualMachinesMeta$Outbound | undefined;
+  meta?: PaginationMeta$Outbound | undefined;
 };
 
 /** @internal */
@@ -75,7 +46,7 @@ export const VirtualMachines$outboundSchema: z.ZodType<
   VirtualMachines
 > = z.object({
   data: z.array(VirtualMachineAttributes$outboundSchema).optional(),
-  meta: z.lazy(() => VirtualMachinesMeta$outboundSchema).optional(),
+  meta: PaginationMeta$outboundSchema.optional(),
 });
 
 export function virtualMachinesToJSON(

package/src/sdk/virtualmachines.ts

@@ -16,6 +16,7 @@ import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { unwrapAsync } from "../types/fp.js";
+import { PageIterator, unwrapResultIterator } from "../types/operations.js";
 
 export class VirtualMachines extends ClientSDK {
   /**
@@ -44,8 +45,10 @@ export class VirtualMachines extends ClientSDK {
   async list(
     request?: operations.IndexVirtualMachineRequest | undefined,
     options?: RequestOptions,
-  ): Promise<models.VirtualMachines> {
-    return unwrapAsync(virtualMachinesList(
+  ): Promise<
+    PageIterator<operations.IndexVirtualMachineResponse, { page: number }>
+  > {
+    return unwrapResultIterator(virtualMachinesList(
       this,
       request,
       options,

package/tests/integration/helpers/mock-data.ts

@@ -137,10 +137,12 @@ export const mockProject = {
     cost: '0.00',
     environment: 'Development',
     stats: {
+      databases: 0,
       ip_addresses: 2,
       prefixes: 0,
       servers: 1,
-      containers: 0,
+      storages: 0,
+      virtual_machines: 0,
       vlans: 1,
     },
     billing: {
@@ -168,10 +170,12 @@ export const mockProjectList = {
         cost: '150.00',
         environment: 'Production',
         stats: {
+          databases: 0,
           ip_addresses: 10,
           prefixes: 1,
           servers: 5,
-          containers: 2,
+          storages: 2,
+          virtual_machines: 1,
           vlans: 3,
         },
         billing: {

package/tests/integration/projects.test.ts

@@ -471,7 +471,9 @@ describe('Projects - Core CRUD Operations', () => {
       expect(project.attributes.stats.ipAddresses).toBe(2);
       expect(project.attributes.stats.servers).toBe(1);
       expect(project.attributes.stats.vlans).toBe(1);
-      expect(project.attributes.stats.containers).toBe(0);
+      expect(project.attributes.stats.storages).toBe(0);
+      expect(project.attributes.stats.virtualMachines).toBe(0);
+      expect(project.attributes.stats.databases).toBe(0);
       expect(project.attributes.stats.prefixes).toBe(0);
     });
   });