latitudesh-typescript-sdk 0.2.3 → 0.3.0

package/src/models/virtualmachineplans.ts

@@ -23,15 +23,33 @@ export type VirtualMachinePlansType = ClosedEnum<
 >;
 
 /**
- * The type of the disk
+ * Detailed vCPU specifications
  */
-export const TypeLocal = {
-  Local: "local",
-} as const;
-/**
- * The type of the disk
- */
-export type TypeLocal = ClosedEnum<typeof TypeLocal>;
+export type Vcpu = {
+  /**
+   * The number of virtual CPUs
+   */
+  count?: number | null | undefined;
+  /**
+   * The CPU clock speed in GHz
+   */
+  clock?: number | null | undefined;
+  /**
+   * The CPU type/model
+   */
+  type?: string | null | undefined;
+};
+
+export type VirtualMachinePlansNic = {
+  /**
+   * NIC speed/type
+   */
+  type?: string | undefined;
+  /**
+   * Number of NICs
+   */
+  count?: string | undefined;
+};
 
 /**
  * The unit of the disk size
@@ -59,9 +77,9 @@ export type Size = {
 
 export type Disk = {
   /**
-   * The type of the disk
+   * The type of the disk (e.g., local SSD, local NVMe)
    */
-  type?: TypeLocal | undefined;
+  type?: string | undefined;
   size?: Size | undefined;
 };
 
@@ -71,9 +89,25 @@ export type VirtualMachinePlansSpecs = {
    */
   memory?: number | undefined;
   /**
-   * The number of virtual CPUs
+   * The GPU type
+   */
+  gpu?: string | undefined;
+  /**
+   * VRAM per GPU in GB
+   */
+  vramPerGpu?: number | null | undefined;
+  /**
+   * The number of virtual CPUs (legacy field)
    */
   vcpus?: number | undefined;
+  /**
+   * Detailed vCPU specifications
+   */
+  vcpu?: Vcpu | undefined;
+  /**
+   * Network interface cards
+   */
+  nics?: Array<VirtualMachinePlansNic> | null | undefined;
   disk?: Disk | undefined;
 };
 
@@ -94,10 +128,42 @@ export type VirtualMachinePlansPricing = {
   brl?: VirtualMachinePlansBRL | undefined;
 };
 
+export type VirtualMachinePlansLocations = {
+  /**
+   * Sites with clusters that support this plan
+   */
+  available?: Array<string> | undefined;
+  /**
+   * Sites with available capacity for this plan
+   */
+  inStock?: Array<string> | undefined;
+};
+
+/**
+ * The stock level in this region
+ */
+export const VirtualMachinePlansRegionStockLevel = {
+  Low: "low",
+  Unavailable: "unavailable",
+  Medium: "medium",
+  High: "high",
+} as const;
+/**
+ * The stock level in this region
+ */
+export type VirtualMachinePlansRegionStockLevel = ClosedEnum<
+  typeof VirtualMachinePlansRegionStockLevel
+>;
+
 export type VirtualMachinePlansRegion = {
   name?: string | undefined;
   available?: Array<string> | undefined;
   pricing?: VirtualMachinePlansPricing | undefined;
+  locations?: VirtualMachinePlansLocations | undefined;
+  /**
+   * The stock level in this region
+   */
+  stockLevel?: VirtualMachinePlansRegionStockLevel | undefined;
 };
 
 /**
@@ -155,11 +221,81 @@ export const VirtualMachinePlansType$outboundSchema: z.ZodNativeEnum<
 > = VirtualMachinePlansType$inboundSchema;
 
 /** @internal */
-export const TypeLocal$inboundSchema: z.ZodNativeEnum<typeof TypeLocal> = z
-  .nativeEnum(TypeLocal);
+export const Vcpu$inboundSchema: z.ZodType<Vcpu, z.ZodTypeDef, unknown> = z
+  .object({
+    count: z.nullable(z.number().int()).optional(),
+    clock: z.nullable(z.number()).optional(),
+    type: z.nullable(z.string()).optional(),
+  });
 /** @internal */
-export const TypeLocal$outboundSchema: z.ZodNativeEnum<typeof TypeLocal> =
-  TypeLocal$inboundSchema;
+export type Vcpu$Outbound = {
+  count?: number | null | undefined;
+  clock?: number | null | undefined;
+  type?: string | null | undefined;
+};
+
+/** @internal */
+export const Vcpu$outboundSchema: z.ZodType<Vcpu$Outbound, z.ZodTypeDef, Vcpu> =
+  z.object({
+    count: z.nullable(z.number().int()).optional(),
+    clock: z.nullable(z.number()).optional(),
+    type: z.nullable(z.string()).optional(),
+  });
+
+export function vcpuToJSON(vcpu: Vcpu): string {
+  return JSON.stringify(Vcpu$outboundSchema.parse(vcpu));
+}
+export function vcpuFromJSON(
+  jsonString: string,
+): SafeParseResult<Vcpu, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Vcpu$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Vcpu' from JSON`,
+  );
+}
+
+/** @internal */
+export const VirtualMachinePlansNic$inboundSchema: z.ZodType<
+  VirtualMachinePlansNic,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.string().optional(),
+  count: z.string().optional(),
+});
+/** @internal */
+export type VirtualMachinePlansNic$Outbound = {
+  type?: string | undefined;
+  count?: string | undefined;
+};
+
+/** @internal */
+export const VirtualMachinePlansNic$outboundSchema: z.ZodType<
+  VirtualMachinePlansNic$Outbound,
+  z.ZodTypeDef,
+  VirtualMachinePlansNic
+> = z.object({
+  type: z.string().optional(),
+  count: z.string().optional(),
+});
+
+export function virtualMachinePlansNicToJSON(
+  virtualMachinePlansNic: VirtualMachinePlansNic,
+): string {
+  return JSON.stringify(
+    VirtualMachinePlansNic$outboundSchema.parse(virtualMachinePlansNic),
+  );
+}
+export function virtualMachinePlansNicFromJSON(
+  jsonString: string,
+): SafeParseResult<VirtualMachinePlansNic, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VirtualMachinePlansNic$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VirtualMachinePlansNic' from JSON`,
+  );
+}
 
 /** @internal */
 export const VirtualMachinePlansUnit$inboundSchema: z.ZodNativeEnum<
@@ -205,7 +341,7 @@ export function sizeFromJSON(
 /** @internal */
 export const Disk$inboundSchema: z.ZodType<Disk, z.ZodTypeDef, unknown> = z
   .object({
-    type: TypeLocal$inboundSchema.optional(),
+    type: z.string().optional(),
     size: z.lazy(() => Size$inboundSchema).optional(),
   });
 /** @internal */
@@ -217,7 +353,7 @@ export type Disk$Outbound = {
 /** @internal */
 export const Disk$outboundSchema: z.ZodType<Disk$Outbound, z.ZodTypeDef, Disk> =
   z.object({
-    type: TypeLocal$outboundSchema.optional(),
+    type: z.string().optional(),
     size: z.lazy(() => Size$outboundSchema).optional(),
   });
 
@@ -241,13 +377,26 @@ export const VirtualMachinePlansSpecs$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   memory: z.number().int().optional(),
+  gpu: z.string().optional(),
+  vram_per_gpu: z.nullable(z.number().int()).optional(),
   vcpus: z.number().int().optional(),
+  vcpu: z.lazy(() => Vcpu$inboundSchema).optional(),
+  nics: z.nullable(z.array(z.lazy(() => VirtualMachinePlansNic$inboundSchema)))
+    .optional(),
   disk: z.lazy(() => Disk$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "vram_per_gpu": "vramPerGpu",
+  });
 });
 /** @internal */
 export type VirtualMachinePlansSpecs$Outbound = {
   memory?: number | undefined;
+  gpu?: string | undefined;
+  vram_per_gpu?: number | null | undefined;
   vcpus?: number | undefined;
+  vcpu?: Vcpu$Outbound | undefined;
+  nics?: Array<VirtualMachinePlansNic$Outbound> | null | undefined;
   disk?: Disk$Outbound | undefined;
 };
 
@@ -258,8 +407,17 @@ export const VirtualMachinePlansSpecs$outboundSchema: z.ZodType<
   VirtualMachinePlansSpecs
 > = z.object({
   memory: z.number().int().optional(),
+  gpu: z.string().optional(),
+  vramPerGpu: z.nullable(z.number().int()).optional(),
   vcpus: z.number().int().optional(),
+  vcpu: z.lazy(() => Vcpu$outboundSchema).optional(),
+  nics: z.nullable(z.array(z.lazy(() => VirtualMachinePlansNic$outboundSchema)))
+    .optional(),
   disk: z.lazy(() => Disk$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    vramPerGpu: "vram_per_gpu",
+  });
 });
 
 export function virtualMachinePlansSpecsToJSON(
@@ -421,6 +579,67 @@ export function virtualMachinePlansPricingFromJSON(
   );
 }
 
+/** @internal */
+export const VirtualMachinePlansLocations$inboundSchema: z.ZodType<
+  VirtualMachinePlansLocations,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  available: z.array(z.string()).optional(),
+  in_stock: z.array(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "in_stock": "inStock",
+  });
+});
+/** @internal */
+export type VirtualMachinePlansLocations$Outbound = {
+  available?: Array<string> | undefined;
+  in_stock?: Array<string> | undefined;
+};
+
+/** @internal */
+export const VirtualMachinePlansLocations$outboundSchema: z.ZodType<
+  VirtualMachinePlansLocations$Outbound,
+  z.ZodTypeDef,
+  VirtualMachinePlansLocations
+> = z.object({
+  available: z.array(z.string()).optional(),
+  inStock: z.array(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    inStock: "in_stock",
+  });
+});
+
+export function virtualMachinePlansLocationsToJSON(
+  virtualMachinePlansLocations: VirtualMachinePlansLocations,
+): string {
+  return JSON.stringify(
+    VirtualMachinePlansLocations$outboundSchema.parse(
+      virtualMachinePlansLocations,
+    ),
+  );
+}
+export function virtualMachinePlansLocationsFromJSON(
+  jsonString: string,
+): SafeParseResult<VirtualMachinePlansLocations, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VirtualMachinePlansLocations$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VirtualMachinePlansLocations' from JSON`,
+  );
+}
+
+/** @internal */
+export const VirtualMachinePlansRegionStockLevel$inboundSchema: z.ZodNativeEnum<
+  typeof VirtualMachinePlansRegionStockLevel
+> = z.nativeEnum(VirtualMachinePlansRegionStockLevel);
+/** @internal */
+export const VirtualMachinePlansRegionStockLevel$outboundSchema:
+  z.ZodNativeEnum<typeof VirtualMachinePlansRegionStockLevel> =
+    VirtualMachinePlansRegionStockLevel$inboundSchema;
+
 /** @internal */
 export const VirtualMachinePlansRegion$inboundSchema: z.ZodType<
   VirtualMachinePlansRegion,
@@ -430,12 +649,21 @@ export const VirtualMachinePlansRegion$inboundSchema: z.ZodType<
   name: z.string().optional(),
   available: z.array(z.string()).optional(),
   pricing: z.lazy(() => VirtualMachinePlansPricing$inboundSchema).optional(),
+  locations: z.lazy(() => VirtualMachinePlansLocations$inboundSchema)
+    .optional(),
+  stock_level: VirtualMachinePlansRegionStockLevel$inboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "stock_level": "stockLevel",
+  });
 });
 /** @internal */
 export type VirtualMachinePlansRegion$Outbound = {
   name?: string | undefined;
   available?: Array<string> | undefined;
   pricing?: VirtualMachinePlansPricing$Outbound | undefined;
+  locations?: VirtualMachinePlansLocations$Outbound | undefined;
+  stock_level?: string | undefined;
 };
 
 /** @internal */
@@ -447,6 +675,13 @@ export const VirtualMachinePlansRegion$outboundSchema: z.ZodType<
   name: z.string().optional(),
   available: z.array(z.string()).optional(),
   pricing: z.lazy(() => VirtualMachinePlansPricing$outboundSchema).optional(),
+  locations: z.lazy(() => VirtualMachinePlansLocations$outboundSchema)
+    .optional(),
+  stockLevel: VirtualMachinePlansRegionStockLevel$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    stockLevel: "stock_level",
+  });
 });
 
 export function virtualMachinePlansRegionToJSON(

package/src/models/virtualmachineupdatepayload.ts

@@ -0,0 +1,174 @@
+/*
+ * 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 VirtualMachineUpdatePayloadType = {
+  VirtualMachines: "virtual_machines",
+} as const;
+export type VirtualMachineUpdatePayloadType = ClosedEnum<
+  typeof VirtualMachineUpdatePayloadType
+>;
+
+export type VirtualMachineUpdatePayloadAttributes = {
+  /**
+   * The new display name (hostname) for the Virtual Machine
+   */
+  name: string;
+};
+
+export type VirtualMachineUpdatePayloadData = {
+  type: VirtualMachineUpdatePayloadType;
+  id?: string | undefined;
+  attributes: VirtualMachineUpdatePayloadAttributes;
+};
+
+export type VirtualMachineUpdatePayload = {
+  data: VirtualMachineUpdatePayloadData;
+};
+
+/** @internal */
+export const VirtualMachineUpdatePayloadType$inboundSchema: z.ZodNativeEnum<
+  typeof VirtualMachineUpdatePayloadType
+> = z.nativeEnum(VirtualMachineUpdatePayloadType);
+/** @internal */
+export const VirtualMachineUpdatePayloadType$outboundSchema: z.ZodNativeEnum<
+  typeof VirtualMachineUpdatePayloadType
+> = VirtualMachineUpdatePayloadType$inboundSchema;
+
+/** @internal */
+export const VirtualMachineUpdatePayloadAttributes$inboundSchema: z.ZodType<
+  VirtualMachineUpdatePayloadAttributes,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string(),
+});
+/** @internal */
+export type VirtualMachineUpdatePayloadAttributes$Outbound = {
+  name: string;
+};
+
+/** @internal */
+export const VirtualMachineUpdatePayloadAttributes$outboundSchema: z.ZodType<
+  VirtualMachineUpdatePayloadAttributes$Outbound,
+  z.ZodTypeDef,
+  VirtualMachineUpdatePayloadAttributes
+> = z.object({
+  name: z.string(),
+});
+
+export function virtualMachineUpdatePayloadAttributesToJSON(
+  virtualMachineUpdatePayloadAttributes: VirtualMachineUpdatePayloadAttributes,
+): string {
+  return JSON.stringify(
+    VirtualMachineUpdatePayloadAttributes$outboundSchema.parse(
+      virtualMachineUpdatePayloadAttributes,
+    ),
+  );
+}
+export function virtualMachineUpdatePayloadAttributesFromJSON(
+  jsonString: string,
+): SafeParseResult<VirtualMachineUpdatePayloadAttributes, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      VirtualMachineUpdatePayloadAttributes$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VirtualMachineUpdatePayloadAttributes' from JSON`,
+  );
+}
+
+/** @internal */
+export const VirtualMachineUpdatePayloadData$inboundSchema: z.ZodType<
+  VirtualMachineUpdatePayloadData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: VirtualMachineUpdatePayloadType$inboundSchema,
+  id: z.string().optional(),
+  attributes: z.lazy(() => VirtualMachineUpdatePayloadAttributes$inboundSchema),
+});
+/** @internal */
+export type VirtualMachineUpdatePayloadData$Outbound = {
+  type: string;
+  id?: string | undefined;
+  attributes: VirtualMachineUpdatePayloadAttributes$Outbound;
+};
+
+/** @internal */
+export const VirtualMachineUpdatePayloadData$outboundSchema: z.ZodType<
+  VirtualMachineUpdatePayloadData$Outbound,
+  z.ZodTypeDef,
+  VirtualMachineUpdatePayloadData
+> = z.object({
+  type: VirtualMachineUpdatePayloadType$outboundSchema,
+  id: z.string().optional(),
+  attributes: z.lazy(() =>
+    VirtualMachineUpdatePayloadAttributes$outboundSchema
+  ),
+});
+
+export function virtualMachineUpdatePayloadDataToJSON(
+  virtualMachineUpdatePayloadData: VirtualMachineUpdatePayloadData,
+): string {
+  return JSON.stringify(
+    VirtualMachineUpdatePayloadData$outboundSchema.parse(
+      virtualMachineUpdatePayloadData,
+    ),
+  );
+}
+export function virtualMachineUpdatePayloadDataFromJSON(
+  jsonString: string,
+): SafeParseResult<VirtualMachineUpdatePayloadData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VirtualMachineUpdatePayloadData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VirtualMachineUpdatePayloadData' from JSON`,
+  );
+}
+
+/** @internal */
+export const VirtualMachineUpdatePayload$inboundSchema: z.ZodType<
+  VirtualMachineUpdatePayload,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.lazy(() => VirtualMachineUpdatePayloadData$inboundSchema),
+});
+/** @internal */
+export type VirtualMachineUpdatePayload$Outbound = {
+  data: VirtualMachineUpdatePayloadData$Outbound;
+};
+
+/** @internal */
+export const VirtualMachineUpdatePayload$outboundSchema: z.ZodType<
+  VirtualMachineUpdatePayload$Outbound,
+  z.ZodTypeDef,
+  VirtualMachineUpdatePayload
+> = z.object({
+  data: z.lazy(() => VirtualMachineUpdatePayloadData$outboundSchema),
+});
+
+export function virtualMachineUpdatePayloadToJSON(
+  virtualMachineUpdatePayload: VirtualMachineUpdatePayload,
+): string {
+  return JSON.stringify(
+    VirtualMachineUpdatePayload$outboundSchema.parse(
+      virtualMachineUpdatePayload,
+    ),
+  );
+}
+export function virtualMachineUpdatePayloadFromJSON(
+  jsonString: string,
+): SafeParseResult<VirtualMachineUpdatePayload, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VirtualMachineUpdatePayload$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VirtualMachineUpdatePayload' from JSON`,
+  );
+}

package/src/models/virtualnetworkdata.ts

@@ -55,7 +55,7 @@ export type VirtualNetworkDataAttributes = {
   description?: string | undefined;
   project?: ProjectInclude | undefined;
   region?: VirtualNetworkDataRegion | undefined;
-  createdAt?: Date | undefined;
+  createdAt?: Date | null | undefined;
   /**
    * Amount of devices assigned to the virtual network
    */
@@ -223,8 +223,9 @@ export const VirtualNetworkDataAttributes$inboundSchema: z.ZodType<
   description: z.string().optional(),
   project: ProjectInclude$inboundSchema.optional(),
   region: z.lazy(() => VirtualNetworkDataRegion$inboundSchema).optional(),
-  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
-    .optional(),
+  created_at: z.nullable(
+    z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  ).optional(),
   assignments_count: z.number().int().optional(),
   tags: z.array(z.lazy(() => Tag$inboundSchema)).optional(),
 }).transform((v) => {
@@ -240,7 +241,7 @@ export type VirtualNetworkDataAttributes$Outbound = {
   description?: string | undefined;
   project?: ProjectInclude$Outbound | undefined;
   region?: VirtualNetworkDataRegion$Outbound | undefined;
-  created_at?: string | undefined;
+  created_at?: string | null | undefined;
   assignments_count?: number | undefined;
   tags?: Array<Tag$Outbound> | undefined;
 };
@@ -256,7 +257,7 @@ export const VirtualNetworkDataAttributes$outboundSchema: z.ZodType<
   description: z.string().optional(),
   project: ProjectInclude$outboundSchema.optional(),
   region: z.lazy(() => VirtualNetworkDataRegion$outboundSchema).optional(),
-  createdAt: z.date().transform(v => v.toISOString()).optional(),
+  createdAt: z.nullable(z.date().transform(v => v.toISOString())).optional(),
   assignmentsCount: z.number().int().optional(),
   tags: z.array(z.lazy(() => Tag$outboundSchema)).optional(),
 }).transform((v) => {

package/src/models/volumedata.ts

@@ -33,10 +33,10 @@ export type Initiator = {
 export type VolumeDataAttributes = {
   name?: string | undefined;
   sizeInGb?: number | undefined;
-  createdAt?: Date | undefined;
+  createdAt?: Date | null | undefined;
   namespaceId?: string | null | undefined;
-  connectorId?: string | undefined;
-  initiators?: Array<Initiator> | undefined;
+  connectorId?: string | null | undefined;
+  initiators?: Array<Initiator> | null | undefined;
   project?: ProjectInclude | undefined;
   team?: TeamInclude | undefined;
 };
@@ -99,11 +99,13 @@ export const VolumeDataAttributes$inboundSchema: z.ZodType<
 > = z.object({
   name: z.string().optional(),
   size_in_gb: z.number().int().optional(),
-  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
-    .optional(),
+  created_at: z.nullable(
+    z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  ).optional(),
   namespace_id: z.nullable(z.string()).optional(),
-  connector_id: z.string().optional(),
-  initiators: z.array(z.lazy(() => Initiator$inboundSchema)).optional(),
+  connector_id: z.nullable(z.string()).optional(),
+  initiators: z.nullable(z.array(z.lazy(() => Initiator$inboundSchema)))
+    .optional(),
   project: ProjectInclude$inboundSchema.optional(),
   team: TeamInclude$inboundSchema.optional(),
 }).transform((v) => {
@@ -118,10 +120,10 @@ export const VolumeDataAttributes$inboundSchema: z.ZodType<
 export type VolumeDataAttributes$Outbound = {
   name?: string | undefined;
   size_in_gb?: number | undefined;
-  created_at?: string | undefined;
+  created_at?: string | null | undefined;
   namespace_id?: string | null | undefined;
-  connector_id?: string | undefined;
-  initiators?: Array<Initiator$Outbound> | undefined;
+  connector_id?: string | null | undefined;
+  initiators?: Array<Initiator$Outbound> | null | undefined;
   project?: ProjectInclude$Outbound | undefined;
   team?: TeamInclude$Outbound | undefined;
 };
@@ -134,10 +136,11 @@ export const VolumeDataAttributes$outboundSchema: z.ZodType<
 > = z.object({
   name: z.string().optional(),
   sizeInGb: z.number().int().optional(),
-  createdAt: z.date().transform(v => v.toISOString()).optional(),
+  createdAt: z.nullable(z.date().transform(v => v.toISOString())).optional(),
   namespaceId: z.nullable(z.string()).optional(),
-  connectorId: z.string().optional(),
-  initiators: z.array(z.lazy(() => Initiator$outboundSchema)).optional(),
+  connectorId: z.nullable(z.string()).optional(),
+  initiators: z.nullable(z.array(z.lazy(() => Initiator$outboundSchema)))
+    .optional(),
   project: ProjectInclude$outboundSchema.optional(),
   team: TeamInclude$outboundSchema.optional(),
 }).transform((v) => {

package/src/sdk/apikeys.ts

@@ -14,10 +14,10 @@ import { unwrapAsync } from "../types/fp.js";
 
 export class ApiKeys extends ClientSDK {
   /**
-   * List API Keys
+   * List API keys
    *
    * @remarks
-   * Returns a list of all API keys from the team members
+   * Returns a list of all API keys.
    */
   async list(
     options?: RequestOptions,
@@ -29,7 +29,7 @@ export class ApiKeys extends ClientSDK {
   }
 
   /**
-   * Create API Key
+   * Create API key
    *
    * @remarks
    * Create a new API Key that is tied to the current user account. The created API key is only listed ONCE upon creation. It can however be regenerated or deleted.
@@ -46,7 +46,7 @@ export class ApiKeys extends ClientSDK {
   }
 
   /**
-   * Rotate API Key
+   * Rotate API key
    *
    * @remarks
    * Rotate an existing API Key, generating a new token. This invalidates the previous key.
@@ -64,7 +64,7 @@ export class ApiKeys extends ClientSDK {
   }
 
   /**
-   * Delete API Key
+   * Delete API key
    *
    * @remarks
    * Delete an existing API Key. Once deleted, the API Key can no longer be used to access the API.
@@ -81,7 +81,7 @@ export class ApiKeys extends ClientSDK {
   }
 
   /**
-   * Update API Key Settings
+   * Update API key settings
    *
    * @remarks
    * Update API Key settings (name, read_only, allowed_ips) without rotating the token.