latitudesh-typescript-sdk 0.6.1 → 0.6.3

package/src/models/filesystemdata.ts

@@ -8,23 +8,37 @@ 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 FilesystemDataType = {
   Filesystems: "filesystems",
 } as const;
 export type FilesystemDataType = ClosedEnum<typeof FilesystemDataType>;
 
-export type FilesystemDataProject = {
-  id?: string | undefined;
-  name?: string | undefined;
-  slug?: string | undefined;
-};
+export const FilesystemStorageClass = {
+  Standard: "standard",
+  HighPerformance: "high_performance",
+} as const;
+export type FilesystemStorageClass = ClosedEnum<typeof FilesystemStorageClass>;
 
 export type FilesystemDataAttributes = {
   name?: string | undefined;
   sizeInGb?: number | undefined;
+  filesystemStorageClass?: FilesystemStorageClass | null | undefined;
   createdAt?: Date | null | undefined;
-  project?: FilesystemDataProject | undefined;
+  project?: ProjectInclude | undefined;
+  team?: TeamInclude | undefined;
 };
 
 export type FilesystemData = {
@@ -43,49 +57,13 @@ export const FilesystemDataType$outboundSchema: z.ZodNativeEnum<
 > = FilesystemDataType$inboundSchema;
 
 /** @internal */
-export const FilesystemDataProject$inboundSchema: z.ZodType<
-  FilesystemDataProject,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  id: z.string().optional(),
-  name: z.string().optional(),
-  slug: z.string().optional(),
-});
-/** @internal */
-export type FilesystemDataProject$Outbound = {
-  id?: string | undefined;
-  name?: string | undefined;
-  slug?: string | undefined;
-};
-
+export const FilesystemStorageClass$inboundSchema: z.ZodNativeEnum<
+  typeof FilesystemStorageClass
+> = z.nativeEnum(FilesystemStorageClass);
 /** @internal */
-export const FilesystemDataProject$outboundSchema: z.ZodType<
-  FilesystemDataProject$Outbound,
-  z.ZodTypeDef,
-  FilesystemDataProject
-> = z.object({
-  id: z.string().optional(),
-  name: z.string().optional(),
-  slug: z.string().optional(),
-});
-
-export function filesystemDataProjectToJSON(
-  filesystemDataProject: FilesystemDataProject,
-): string {
-  return JSON.stringify(
-    FilesystemDataProject$outboundSchema.parse(filesystemDataProject),
-  );
-}
-export function filesystemDataProjectFromJSON(
-  jsonString: string,
-): SafeParseResult<FilesystemDataProject, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => FilesystemDataProject$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'FilesystemDataProject' from JSON`,
-  );
-}
+export const FilesystemStorageClass$outboundSchema: z.ZodNativeEnum<
+  typeof FilesystemStorageClass
+> = FilesystemStorageClass$inboundSchema;
 
 /** @internal */
 export const FilesystemDataAttributes$inboundSchema: z.ZodType<
@@ -95,13 +73,16 @@ export const FilesystemDataAttributes$inboundSchema: z.ZodType<
 > = z.object({
   name: z.string().optional(),
   size_in_gb: z.number().int().optional(),
+  storage_class: z.nullable(FilesystemStorageClass$inboundSchema).optional(),
   created_at: z.nullable(
     z.string().datetime({ offset: true }).transform(v => new Date(v)),
   ).optional(),
-  project: z.lazy(() => FilesystemDataProject$inboundSchema).optional(),
+  project: ProjectInclude$inboundSchema.optional(),
+  team: TeamInclude$inboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     "size_in_gb": "sizeInGb",
+    "storage_class": "filesystemStorageClass",
     "created_at": "createdAt",
   });
 });
@@ -109,8 +90,10 @@ export const FilesystemDataAttributes$inboundSchema: z.ZodType<
 export type FilesystemDataAttributes$Outbound = {
   name?: string | undefined;
   size_in_gb?: number | undefined;
+  storage_class?: string | null | undefined;
   created_at?: string | null | undefined;
-  project?: FilesystemDataProject$Outbound | undefined;
+  project?: ProjectInclude$Outbound | undefined;
+  team?: TeamInclude$Outbound | undefined;
 };
 
 /** @internal */
@@ -121,11 +104,15 @@ export const FilesystemDataAttributes$outboundSchema: z.ZodType<
 > = z.object({
   name: z.string().optional(),
   sizeInGb: z.number().int().optional(),
+  filesystemStorageClass: z.nullable(FilesystemStorageClass$outboundSchema)
+    .optional(),
   createdAt: z.nullable(z.date().transform(v => v.toISOString())).optional(),
-  project: z.lazy(() => FilesystemDataProject$outboundSchema).optional(),
+  project: ProjectInclude$outboundSchema.optional(),
+  team: TeamInclude$outboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     sizeInGb: "size_in_gb",
+    filesystemStorageClass: "storage_class",
     createdAt: "created_at",
   });
 });

package/src/models/filesystems.ts

@@ -0,0 +1,90 @@
+/*
+ * 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 {
+  FilesystemData,
+  FilesystemData$inboundSchema,
+  FilesystemData$Outbound,
+  FilesystemData$outboundSchema,
+} from "./filesystemdata.js";
+
+export type FilesystemsMeta = {};
+
+export type Filesystems = {
+  data?: Array<FilesystemData> | undefined;
+  meta?: FilesystemsMeta | undefined;
+};
+
+/** @internal */
+export const FilesystemsMeta$inboundSchema: z.ZodType<
+  FilesystemsMeta,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+/** @internal */
+export type FilesystemsMeta$Outbound = {};
+
+/** @internal */
+export const FilesystemsMeta$outboundSchema: z.ZodType<
+  FilesystemsMeta$Outbound,
+  z.ZodTypeDef,
+  FilesystemsMeta
+> = z.object({});
+
+export function filesystemsMetaToJSON(
+  filesystemsMeta: FilesystemsMeta,
+): string {
+  return JSON.stringify(FilesystemsMeta$outboundSchema.parse(filesystemsMeta));
+}
+export function filesystemsMetaFromJSON(
+  jsonString: string,
+): SafeParseResult<FilesystemsMeta, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FilesystemsMeta$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilesystemsMeta' from JSON`,
+  );
+}
+
+/** @internal */
+export const Filesystems$inboundSchema: z.ZodType<
+  Filesystems,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.array(FilesystemData$inboundSchema).optional(),
+  meta: z.lazy(() => FilesystemsMeta$inboundSchema).optional(),
+});
+/** @internal */
+export type Filesystems$Outbound = {
+  data?: Array<FilesystemData$Outbound> | undefined;
+  meta?: FilesystemsMeta$Outbound | undefined;
+};
+
+/** @internal */
+export const Filesystems$outboundSchema: z.ZodType<
+  Filesystems$Outbound,
+  z.ZodTypeDef,
+  Filesystems
+> = z.object({
+  data: z.array(FilesystemData$outboundSchema).optional(),
+  meta: z.lazy(() => FilesystemsMeta$outboundSchema).optional(),
+});
+
+export function filesystemsToJSON(filesystems: Filesystems): string {
+  return JSON.stringify(Filesystems$outboundSchema.parse(filesystems));
+}
+export function filesystemsFromJSON(
+  jsonString: string,
+): SafeParseResult<Filesystems, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Filesystems$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Filesystems' from JSON`,
+  );
+}

package/src/models/firewallassignmentdata.ts

@@ -22,8 +22,14 @@ export type FirewallAssignmentDataServer = {
   hostname?: string | undefined;
 };
 
+export type FirewallAssignmentDataFirewall = {
+  id?: string | undefined;
+  name?: string | undefined;
+};
+
 export type FirewallAssignmentDataAttributes = {
   server?: FirewallAssignmentDataServer | undefined;
+  firewall?: FirewallAssignmentDataFirewall | undefined;
   firewallId?: string | undefined;
 };
 
@@ -97,6 +103,50 @@ export function firewallAssignmentDataServerFromJSON(
   );
 }
 
+/** @internal */
+export const FirewallAssignmentDataFirewall$inboundSchema: z.ZodType<
+  FirewallAssignmentDataFirewall,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string().optional(),
+  name: z.string().optional(),
+});
+/** @internal */
+export type FirewallAssignmentDataFirewall$Outbound = {
+  id?: string | undefined;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const FirewallAssignmentDataFirewall$outboundSchema: z.ZodType<
+  FirewallAssignmentDataFirewall$Outbound,
+  z.ZodTypeDef,
+  FirewallAssignmentDataFirewall
+> = z.object({
+  id: z.string().optional(),
+  name: z.string().optional(),
+});
+
+export function firewallAssignmentDataFirewallToJSON(
+  firewallAssignmentDataFirewall: FirewallAssignmentDataFirewall,
+): string {
+  return JSON.stringify(
+    FirewallAssignmentDataFirewall$outboundSchema.parse(
+      firewallAssignmentDataFirewall,
+    ),
+  );
+}
+export function firewallAssignmentDataFirewallFromJSON(
+  jsonString: string,
+): SafeParseResult<FirewallAssignmentDataFirewall, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FirewallAssignmentDataFirewall$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FirewallAssignmentDataFirewall' from JSON`,
+  );
+}
+
 /** @internal */
 export const FirewallAssignmentDataAttributes$inboundSchema: z.ZodType<
   FirewallAssignmentDataAttributes,
@@ -104,6 +154,8 @@ export const FirewallAssignmentDataAttributes$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   server: z.lazy(() => FirewallAssignmentDataServer$inboundSchema).optional(),
+  firewall: z.lazy(() => FirewallAssignmentDataFirewall$inboundSchema)
+    .optional(),
   firewall_id: z.string().optional(),
 }).transform((v) => {
   return remap$(v, {
@@ -113,6 +165,7 @@ export const FirewallAssignmentDataAttributes$inboundSchema: z.ZodType<
 /** @internal */
 export type FirewallAssignmentDataAttributes$Outbound = {
   server?: FirewallAssignmentDataServer$Outbound | undefined;
+  firewall?: FirewallAssignmentDataFirewall$Outbound | undefined;
   firewall_id?: string | undefined;
 };
 
@@ -123,6 +176,8 @@ export const FirewallAssignmentDataAttributes$outboundSchema: z.ZodType<
   FirewallAssignmentDataAttributes
 > = z.object({
   server: z.lazy(() => FirewallAssignmentDataServer$outboundSchema).optional(),
+  firewall: z.lazy(() => FirewallAssignmentDataFirewall$outboundSchema)
+    .optional(),
   firewallId: z.string().optional(),
 }).transform((v) => {
   return remap$(v, {

package/src/models/firewalldata.ts

@@ -24,6 +24,10 @@ export type Rule = {
   to?: string | undefined;
   port?: string | undefined;
   protocol?: string | undefined;
+  /**
+   * True when this rule was seeded by Latitude when the firewall was created (cannot be deleted); false for user-added rules.
+   */
+  default?: boolean | undefined;
   /**
    * Optional description explaining the purpose of this rule
    */
@@ -64,6 +68,7 @@ export const Rule$inboundSchema: z.ZodType<Rule, z.ZodTypeDef, unknown> = z
     to: z.string().optional(),
     port: z.string().optional(),
     protocol: z.string().optional(),
+    default: z.boolean().optional(),
     description: z.nullable(z.string()).optional(),
   });
 /** @internal */
@@ -72,6 +77,7 @@ export type Rule$Outbound = {
   to?: string | undefined;
   port?: string | undefined;
   protocol?: string | undefined;
+  default?: boolean | undefined;
   description?: string | null | undefined;
 };
 
@@ -82,6 +88,7 @@ export const Rule$outboundSchema: z.ZodType<Rule$Outbound, z.ZodTypeDef, Rule> =
     to: z.string().optional(),
     port: z.string().optional(),
     protocol: z.string().optional(),
+    default: z.boolean().optional(),
     description: z.nullable(z.string()).optional(),
   });
 

package/src/models/index.ts

@@ -22,6 +22,7 @@ export * from "./errorobject.js";
 export * from "./eventdata.js";
 export * from "./events.js";
 export * from "./filesystemdata.js";
+export * from "./filesystems.js";
 export * from "./firewall.js";
 export * from "./firewallassignmentdata.js";
 export * from "./firewallassignments.js";

package/src/models/team.ts

@@ -25,6 +25,18 @@ export type TeamBilling = {
   customerBillingId?: string | undefined;
 };
 
+export type TeamLimits = {
+  bareMetal?: number | null | undefined;
+  bareMetalGpu?: number | null | undefined;
+  virtualMachine?: number | null | undefined;
+  virtualMachineGpu?: number | null | undefined;
+  elasticIp?: number | null | undefined;
+  virtualNetwork?: number | null | undefined;
+  database?: number | null | undefined;
+  filesystem?: number | null | undefined;
+  blockStorage?: number | null | undefined;
+};
+
 export type TeamAttributes = {
   name?: string | undefined;
   slug?: string | undefined;
@@ -39,6 +51,7 @@ export type TeamAttributes = {
   owner?: UserInclude | undefined;
   billing?: TeamBilling | undefined;
   featureFlags?: Array<string> | undefined;
+  limits?: TeamLimits | undefined;
 };
 
 export type Team = {
@@ -92,6 +105,85 @@ export function teamBillingFromJSON(
   );
 }
 
+/** @internal */
+export const TeamLimits$inboundSchema: z.ZodType<
+  TeamLimits,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  bare_metal: z.nullable(z.number().int()).optional(),
+  bare_metal_gpu: z.nullable(z.number().int()).optional(),
+  virtual_machine: z.nullable(z.number().int()).optional(),
+  virtual_machine_gpu: z.nullable(z.number().int()).optional(),
+  elastic_ip: z.nullable(z.number().int()).optional(),
+  virtual_network: z.nullable(z.number().int()).optional(),
+  database: z.nullable(z.number().int()).optional(),
+  filesystem: z.nullable(z.number().int()).optional(),
+  block_storage: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "bare_metal": "bareMetal",
+    "bare_metal_gpu": "bareMetalGpu",
+    "virtual_machine": "virtualMachine",
+    "virtual_machine_gpu": "virtualMachineGpu",
+    "elastic_ip": "elasticIp",
+    "virtual_network": "virtualNetwork",
+    "block_storage": "blockStorage",
+  });
+});
+/** @internal */
+export type TeamLimits$Outbound = {
+  bare_metal?: number | null | undefined;
+  bare_metal_gpu?: number | null | undefined;
+  virtual_machine?: number | null | undefined;
+  virtual_machine_gpu?: number | null | undefined;
+  elastic_ip?: number | null | undefined;
+  virtual_network?: number | null | undefined;
+  database?: number | null | undefined;
+  filesystem?: number | null | undefined;
+  block_storage?: number | null | undefined;
+};
+
+/** @internal */
+export const TeamLimits$outboundSchema: z.ZodType<
+  TeamLimits$Outbound,
+  z.ZodTypeDef,
+  TeamLimits
+> = z.object({
+  bareMetal: z.nullable(z.number().int()).optional(),
+  bareMetalGpu: z.nullable(z.number().int()).optional(),
+  virtualMachine: z.nullable(z.number().int()).optional(),
+  virtualMachineGpu: z.nullable(z.number().int()).optional(),
+  elasticIp: z.nullable(z.number().int()).optional(),
+  virtualNetwork: z.nullable(z.number().int()).optional(),
+  database: z.nullable(z.number().int()).optional(),
+  filesystem: z.nullable(z.number().int()).optional(),
+  blockStorage: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    bareMetal: "bare_metal",
+    bareMetalGpu: "bare_metal_gpu",
+    virtualMachine: "virtual_machine",
+    virtualMachineGpu: "virtual_machine_gpu",
+    elasticIp: "elastic_ip",
+    virtualNetwork: "virtual_network",
+    blockStorage: "block_storage",
+  });
+});
+
+export function teamLimitsToJSON(teamLimits: TeamLimits): string {
+  return JSON.stringify(TeamLimits$outboundSchema.parse(teamLimits));
+}
+export function teamLimitsFromJSON(
+  jsonString: string,
+): SafeParseResult<TeamLimits, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TeamLimits$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TeamLimits' from JSON`,
+  );
+}
+
 /** @internal */
 export const TeamAttributes$inboundSchema: z.ZodType<
   TeamAttributes,
@@ -111,6 +203,7 @@ export const TeamAttributes$inboundSchema: z.ZodType<
   owner: UserInclude$inboundSchema.optional(),
   billing: z.lazy(() => TeamBilling$inboundSchema).optional(),
   feature_flags: z.array(z.string()).optional(),
+  limits: z.lazy(() => TeamLimits$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "created_at": "createdAt",
@@ -134,6 +227,7 @@ export type TeamAttributes$Outbound = {
   owner?: UserInclude$Outbound | undefined;
   billing?: TeamBilling$Outbound | undefined;
   feature_flags?: Array<string> | undefined;
+  limits?: TeamLimits$Outbound | undefined;
 };
 
 /** @internal */
@@ -155,6 +249,7 @@ export const TeamAttributes$outboundSchema: z.ZodType<
   owner: UserInclude$outboundSchema.optional(),
   billing: z.lazy(() => TeamBilling$outboundSchema).optional(),
   featureFlags: z.array(z.string()).optional(),
+  limits: z.lazy(() => TeamLimits$outboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     createdAt: "created_at",

package/src/models/teaminclude.ts

@@ -10,6 +10,18 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
 export type Currency = {};
 
+export type TeamIncludeLimits = {
+  bareMetal?: number | null | undefined;
+  bareMetalGpu?: number | null | undefined;
+  virtualMachine?: number | null | undefined;
+  virtualMachineGpu?: number | null | undefined;
+  elasticIp?: number | null | undefined;
+  virtualNetwork?: number | null | undefined;
+  database?: number | null | undefined;
+  filesystem?: number | null | undefined;
+  blockStorage?: number | null | undefined;
+};
+
 export type TeamInclude = {
   id?: string | undefined;
   name?: string | undefined;
@@ -19,6 +31,7 @@ export type TeamInclude = {
   currency?: Currency | undefined;
   status?: string | undefined;
   featureFlags?: Array<string> | undefined;
+  limits?: TeamIncludeLimits | undefined;
 };
 
 /** @internal */
@@ -50,6 +63,89 @@ export function currencyFromJSON(
   );
 }
 
+/** @internal */
+export const TeamIncludeLimits$inboundSchema: z.ZodType<
+  TeamIncludeLimits,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  bare_metal: z.nullable(z.number().int()).optional(),
+  bare_metal_gpu: z.nullable(z.number().int()).optional(),
+  virtual_machine: z.nullable(z.number().int()).optional(),
+  virtual_machine_gpu: z.nullable(z.number().int()).optional(),
+  elastic_ip: z.nullable(z.number().int()).optional(),
+  virtual_network: z.nullable(z.number().int()).optional(),
+  database: z.nullable(z.number().int()).optional(),
+  filesystem: z.nullable(z.number().int()).optional(),
+  block_storage: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "bare_metal": "bareMetal",
+    "bare_metal_gpu": "bareMetalGpu",
+    "virtual_machine": "virtualMachine",
+    "virtual_machine_gpu": "virtualMachineGpu",
+    "elastic_ip": "elasticIp",
+    "virtual_network": "virtualNetwork",
+    "block_storage": "blockStorage",
+  });
+});
+/** @internal */
+export type TeamIncludeLimits$Outbound = {
+  bare_metal?: number | null | undefined;
+  bare_metal_gpu?: number | null | undefined;
+  virtual_machine?: number | null | undefined;
+  virtual_machine_gpu?: number | null | undefined;
+  elastic_ip?: number | null | undefined;
+  virtual_network?: number | null | undefined;
+  database?: number | null | undefined;
+  filesystem?: number | null | undefined;
+  block_storage?: number | null | undefined;
+};
+
+/** @internal */
+export const TeamIncludeLimits$outboundSchema: z.ZodType<
+  TeamIncludeLimits$Outbound,
+  z.ZodTypeDef,
+  TeamIncludeLimits
+> = z.object({
+  bareMetal: z.nullable(z.number().int()).optional(),
+  bareMetalGpu: z.nullable(z.number().int()).optional(),
+  virtualMachine: z.nullable(z.number().int()).optional(),
+  virtualMachineGpu: z.nullable(z.number().int()).optional(),
+  elasticIp: z.nullable(z.number().int()).optional(),
+  virtualNetwork: z.nullable(z.number().int()).optional(),
+  database: z.nullable(z.number().int()).optional(),
+  filesystem: z.nullable(z.number().int()).optional(),
+  blockStorage: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    bareMetal: "bare_metal",
+    bareMetalGpu: "bare_metal_gpu",
+    virtualMachine: "virtual_machine",
+    virtualMachineGpu: "virtual_machine_gpu",
+    elasticIp: "elastic_ip",
+    virtualNetwork: "virtual_network",
+    blockStorage: "block_storage",
+  });
+});
+
+export function teamIncludeLimitsToJSON(
+  teamIncludeLimits: TeamIncludeLimits,
+): string {
+  return JSON.stringify(
+    TeamIncludeLimits$outboundSchema.parse(teamIncludeLimits),
+  );
+}
+export function teamIncludeLimitsFromJSON(
+  jsonString: string,
+): SafeParseResult<TeamIncludeLimits, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TeamIncludeLimits$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TeamIncludeLimits' from JSON`,
+  );
+}
+
 /** @internal */
 export const TeamInclude$inboundSchema: z.ZodType<
   TeamInclude,
@@ -64,6 +160,7 @@ export const TeamInclude$inboundSchema: z.ZodType<
   currency: z.lazy(() => Currency$inboundSchema).optional(),
   status: z.string().optional(),
   feature_flags: z.array(z.string()).optional(),
+  limits: z.lazy(() => TeamIncludeLimits$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "feature_flags": "featureFlags",
@@ -79,6 +176,7 @@ export type TeamInclude$Outbound = {
   currency?: Currency$Outbound | undefined;
   status?: string | undefined;
   feature_flags?: Array<string> | undefined;
+  limits?: TeamIncludeLimits$Outbound | undefined;
 };
 
 /** @internal */
@@ -95,6 +193,7 @@ export const TeamInclude$outboundSchema: z.ZodType<
   currency: z.lazy(() => Currency$outboundSchema).optional(),
   status: z.string().optional(),
   featureFlags: z.array(z.string()).optional(),
+  limits: z.lazy(() => TeamIncludeLimits$outboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     featureFlags: "feature_flags",

package/src/models/virtualmachinepayload.ts

@@ -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/sdk/filesystemstorage.ts

@@ -7,6 +7,7 @@ import { filesystemStorageDeleteFilesystem } from "../funcs/filesystemStorageDel
 import { filesystemStorageListFilesystems } from "../funcs/filesystemStorageListFilesystems.js";
 import { filesystemStorageUpdateFilesystem } from "../funcs/filesystemStorageUpdateFilesystem.js";
 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";
 
@@ -37,7 +38,7 @@ export class FilesystemStorage extends ClientSDK {
   async listFilesystems(
     request?: operations.GetStorageFilesystemsRequest | undefined,
     options?: RequestOptions,
-  ): Promise<void> {
+  ): Promise<models.Filesystems> {
     return unwrapAsync(filesystemStorageListFilesystems(
       this,
       request,