latitudesh-typescript-sdk 0.8.2 → 0.8.4

package/src/models/operations/updateproject.ts

@@ -33,7 +33,7 @@ export type UpdateProjectAttributes2 = {
 };
 
 export type UpdateProjectData2 = {
-  id?: string | undefined;
+  id: string;
   type: UpdateProjectType2;
   attributes?: UpdateProjectAttributes2 | undefined;
 };
@@ -81,12 +81,10 @@ export const UpdateProjectAttributes2$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  name: z.string().default("A brand new name for the virtual network"),
-  description: z.string().default(
-    "A brand new description for the virtual network",
-  ),
+  name: z.string().optional(),
+  description: z.string().optional(),
   environment: UpdateProjectEnvironment2$inboundSchema.optional(),
-  bandwidth_alert: z.boolean().default(false),
+  bandwidth_alert: z.boolean().optional(),
   tags: z.array(z.string()).optional(),
 }).transform((v) => {
   return remap$(v, {
@@ -95,10 +93,10 @@ export const UpdateProjectAttributes2$inboundSchema: z.ZodType<
 });
 /** @internal */
 export type UpdateProjectAttributes2$Outbound = {
-  name: string;
-  description: string;
+  name?: string | undefined;
+  description?: string | undefined;
   environment?: string | undefined;
-  bandwidth_alert: boolean;
+  bandwidth_alert?: boolean | undefined;
   tags?: Array<string> | undefined;
 };
 
@@ -108,12 +106,10 @@ export const UpdateProjectAttributes2$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   UpdateProjectAttributes2
 > = z.object({
-  name: z.string().default("A brand new name for the virtual network"),
-  description: z.string().default(
-    "A brand new description for the virtual network",
-  ),
+  name: z.string().optional(),
+  description: z.string().optional(),
   environment: UpdateProjectEnvironment2$outboundSchema.optional(),
-  bandwidthAlert: z.boolean().default(false),
+  bandwidthAlert: z.boolean().optional(),
   tags: z.array(z.string()).optional(),
 }).transform((v) => {
   return remap$(v, {
@@ -144,7 +140,7 @@ export const UpdateProjectData2$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.string().default("proj_81EVOtR1N4J2Z"),
+  id: z.string(),
   type: UpdateProjectType2$inboundSchema,
   attributes: z.lazy(() => UpdateProjectAttributes2$inboundSchema).optional(),
 });
@@ -161,7 +157,7 @@ export const UpdateProjectData2$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   UpdateProjectData2
 > = z.object({
-  id: z.string().default("proj_81EVOtR1N4J2Z"),
+  id: z.string(),
   type: UpdateProjectType2$outboundSchema,
   attributes: z.lazy(() => UpdateProjectAttributes2$outboundSchema).optional(),
 });

package/src/models/outofbandconnection.ts

@@ -8,7 +8,7 @@ import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
-export type SshKey = {
+export type OutOfBandConnectionSshKey = {
   id?: string | undefined;
   description?: string | undefined;
   fingerprint?: string | undefined;
@@ -23,7 +23,7 @@ export type OutOfBandConnectionCredentials = {
 };
 
 export type OutOfBandConnectionAttributes = {
-  sshKey?: SshKey | undefined;
+  sshKey?: OutOfBandConnectionSshKey | undefined;
   createdAt?: string | undefined;
   username?: string | undefined;
   /**
@@ -47,40 +47,47 @@ export type OutOfBandConnection = {
 };
 
 /** @internal */
-export const SshKey$inboundSchema: z.ZodType<SshKey, z.ZodTypeDef, unknown> = z
-  .object({
-    id: z.string().optional(),
-    description: z.string().optional(),
-    fingerprint: z.string().optional(),
-  });
+export const OutOfBandConnectionSshKey$inboundSchema: z.ZodType<
+  OutOfBandConnectionSshKey,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string().optional(),
+  description: z.string().optional(),
+  fingerprint: z.string().optional(),
+});
 /** @internal */
-export type SshKey$Outbound = {
+export type OutOfBandConnectionSshKey$Outbound = {
   id?: string | undefined;
   description?: string | undefined;
   fingerprint?: string | undefined;
 };
 
 /** @internal */
-export const SshKey$outboundSchema: z.ZodType<
-  SshKey$Outbound,
+export const OutOfBandConnectionSshKey$outboundSchema: z.ZodType<
+  OutOfBandConnectionSshKey$Outbound,
   z.ZodTypeDef,
-  SshKey
+  OutOfBandConnectionSshKey
 > = z.object({
   id: z.string().optional(),
   description: z.string().optional(),
   fingerprint: z.string().optional(),
 });
 
-export function sshKeyToJSON(sshKey: SshKey): string {
-  return JSON.stringify(SshKey$outboundSchema.parse(sshKey));
+export function outOfBandConnectionSshKeyToJSON(
+  outOfBandConnectionSshKey: OutOfBandConnectionSshKey,
+): string {
+  return JSON.stringify(
+    OutOfBandConnectionSshKey$outboundSchema.parse(outOfBandConnectionSshKey),
+  );
 }
-export function sshKeyFromJSON(
+export function outOfBandConnectionSshKeyFromJSON(
   jsonString: string,
-): SafeParseResult<SshKey, SDKValidationError> {
+): SafeParseResult<OutOfBandConnectionSshKey, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => SshKey$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SshKey' from JSON`,
+    (x) => OutOfBandConnectionSshKey$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OutOfBandConnectionSshKey' from JSON`,
   );
 }
 
@@ -134,7 +141,7 @@ export const OutOfBandConnectionAttributes$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  ssh_key: z.lazy(() => SshKey$inboundSchema).optional(),
+  ssh_key: z.lazy(() => OutOfBandConnectionSshKey$inboundSchema).optional(),
   created_at: z.string().optional(),
   username: z.string().optional(),
   credentials: z.lazy(() => OutOfBandConnectionCredentials$inboundSchema)
@@ -153,7 +160,7 @@ export const OutOfBandConnectionAttributes$inboundSchema: z.ZodType<
 });
 /** @internal */
 export type OutOfBandConnectionAttributes$Outbound = {
-  ssh_key?: SshKey$Outbound | undefined;
+  ssh_key?: OutOfBandConnectionSshKey$Outbound | undefined;
   created_at?: string | undefined;
   username?: string | undefined;
   credentials?: OutOfBandConnectionCredentials$Outbound | undefined;
@@ -169,7 +176,7 @@ export const OutOfBandConnectionAttributes$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   OutOfBandConnectionAttributes
 > = z.object({
-  sshKey: z.lazy(() => SshKey$outboundSchema).optional(),
+  sshKey: z.lazy(() => OutOfBandConnectionSshKey$outboundSchema).optional(),
   createdAt: z.string().optional(),
   username: z.string().optional(),
   credentials: z.lazy(() => OutOfBandConnectionCredentials$outboundSchema)

package/src/models/serverdata.ts

@@ -27,6 +27,13 @@ import {
   TeamInclude$outboundSchema,
 } from "./teaminclude.js";
 
+export type ServerDataTag = {
+  id?: string | undefined;
+  name?: string | undefined;
+  description?: string | null | undefined;
+  color?: string | null | undefined;
+};
+
 /**
  * `on` - The server is powered ON
  *
@@ -163,11 +170,13 @@ export type Interface = {
 };
 
 export type ServerDataAttributes = {
+  tags?: Array<ServerDataTag> | undefined;
   hostname?: string | undefined;
   /**
    * The server label
    */
   label?: string | undefined;
+  price?: number | null | undefined;
   /**
    * `on` - The server is powered ON
    *
@@ -180,7 +189,7 @@ export type ServerDataAttributes = {
    * `rescue_mode` - The server is in rescue mode
    */
   status?: ServerDataStatus | undefined;
-  ipmiStatus?: IpmiStatus | undefined;
+  ipmiStatus?: IpmiStatus | null | undefined;
   /**
    * The server role (e.g. Bare Metal)
    */
@@ -207,6 +216,50 @@ export type ServerData = {
   attributes?: ServerDataAttributes | undefined;
 };
 
+/** @internal */
+export const ServerDataTag$inboundSchema: z.ZodType<
+  ServerDataTag,
+  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 ServerDataTag$Outbound = {
+  id?: string | undefined;
+  name?: string | undefined;
+  description?: string | null | undefined;
+  color?: string | null | undefined;
+};
+
+/** @internal */
+export const ServerDataTag$outboundSchema: z.ZodType<
+  ServerDataTag$Outbound,
+  z.ZodTypeDef,
+  ServerDataTag
+> = z.object({
+  id: z.string().optional(),
+  name: z.string().optional(),
+  description: z.nullable(z.string()).optional(),
+  color: z.nullable(z.string()).optional(),
+});
+
+export function serverDataTagToJSON(serverDataTag: ServerDataTag): string {
+  return JSON.stringify(ServerDataTag$outboundSchema.parse(serverDataTag));
+}
+export function serverDataTagFromJSON(
+  jsonString: string,
+): SafeParseResult<ServerDataTag, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ServerDataTag$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ServerDataTag' from JSON`,
+  );
+}
+
 /** @internal */
 export const ServerDataStatus$inboundSchema: z.ZodNativeEnum<
   typeof ServerDataStatus
@@ -534,10 +587,12 @@ export const ServerDataAttributes$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
+  tags: z.array(z.lazy(() => ServerDataTag$inboundSchema)).optional(),
   hostname: z.string().optional(),
   label: z.string().optional(),
+  price: z.nullable(z.number()).optional(),
   status: ServerDataStatus$inboundSchema.optional(),
-  ipmi_status: IpmiStatus$inboundSchema.optional(),
+  ipmi_status: z.nullable(IpmiStatus$inboundSchema).optional(),
   role: z.string().optional(),
   site: z.string().optional(),
   locked: z.boolean().optional(),
@@ -567,10 +622,12 @@ export const ServerDataAttributes$inboundSchema: z.ZodType<
 });
 /** @internal */
 export type ServerDataAttributes$Outbound = {
+  tags?: Array<ServerDataTag$Outbound> | undefined;
   hostname?: string | undefined;
   label?: string | undefined;
+  price?: number | null | undefined;
   status?: string | undefined;
-  ipmi_status?: string | undefined;
+  ipmi_status?: string | null | undefined;
   role?: string | undefined;
   site?: string | undefined;
   locked?: boolean | undefined;
@@ -594,10 +651,12 @@ export const ServerDataAttributes$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ServerDataAttributes
 > = z.object({
+  tags: z.array(z.lazy(() => ServerDataTag$outboundSchema)).optional(),
   hostname: z.string().optional(),
   label: z.string().optional(),
+  price: z.nullable(z.number()).optional(),
   status: ServerDataStatus$outboundSchema.optional(),
-  ipmiStatus: IpmiStatus$outboundSchema.optional(),
+  ipmiStatus: z.nullable(IpmiStatus$outboundSchema).optional(),
   role: z.string().optional(),
   site: z.string().optional(),
   locked: z.boolean().optional(),

package/src/models/storageplandata.ts

@@ -3,6 +3,7 @@
  */
 
 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";
@@ -13,16 +14,46 @@ export const StoragePlanDataType = {
 } as const;
 export type StoragePlanDataType = ClosedEnum<typeof StoragePlanDataType>;
 
-export type StoragePlanDataPricing = {
+export const StoragePlanStorageType = {
+  Filesystem: "filesystem",
+  Object: "object",
+} as const;
+export type StoragePlanStorageType = ClosedEnum<typeof StoragePlanStorageType>;
+
+export const StoragePlanStorageClass = {
+  Standard: "standard",
+  HighPerformance: "high_performance",
+} as const;
+export type StoragePlanStorageClass = ClosedEnum<
+  typeof StoragePlanStorageClass
+>;
+
+export type StoragePlanDataUSD = {
   month?: number | undefined;
 };
 
-export type StoragePlanDataAttributes = {
+export type StoragePlanDataBRL = {
+  month?: number | undefined;
+};
+
+export type StoragePlanDataPricing = {
+  usd?: StoragePlanDataUSD | undefined;
+  brl?: StoragePlanDataBRL | undefined;
+};
+
+export type StoragePlanDataRegion = {
   name?: string | undefined;
   locations?: Array<string> | undefined;
   pricing?: StoragePlanDataPricing | undefined;
 };
 
+export type StoragePlanDataAttributes = {
+  name?: string | undefined;
+  storagePlanStorageType?: StoragePlanStorageType | undefined;
+  storagePlanStorageClass?: StoragePlanStorageClass | null | undefined;
+  regions?: Array<StoragePlanDataRegion> | undefined;
+};
+
 export type StoragePlanData = {
   id?: string | undefined;
   type?: StoragePlanDataType | undefined;
@@ -38,17 +69,120 @@ export const StoragePlanDataType$outboundSchema: z.ZodNativeEnum<
   typeof StoragePlanDataType
 > = StoragePlanDataType$inboundSchema;
 
+/** @internal */
+export const StoragePlanStorageType$inboundSchema: z.ZodNativeEnum<
+  typeof StoragePlanStorageType
+> = z.nativeEnum(StoragePlanStorageType);
+/** @internal */
+export const StoragePlanStorageType$outboundSchema: z.ZodNativeEnum<
+  typeof StoragePlanStorageType
+> = StoragePlanStorageType$inboundSchema;
+
+/** @internal */
+export const StoragePlanStorageClass$inboundSchema: z.ZodNativeEnum<
+  typeof StoragePlanStorageClass
+> = z.nativeEnum(StoragePlanStorageClass);
+/** @internal */
+export const StoragePlanStorageClass$outboundSchema: z.ZodNativeEnum<
+  typeof StoragePlanStorageClass
+> = StoragePlanStorageClass$inboundSchema;
+
+/** @internal */
+export const StoragePlanDataUSD$inboundSchema: z.ZodType<
+  StoragePlanDataUSD,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  month: z.number().optional(),
+});
+/** @internal */
+export type StoragePlanDataUSD$Outbound = {
+  month?: number | undefined;
+};
+
+/** @internal */
+export const StoragePlanDataUSD$outboundSchema: z.ZodType<
+  StoragePlanDataUSD$Outbound,
+  z.ZodTypeDef,
+  StoragePlanDataUSD
+> = z.object({
+  month: z.number().optional(),
+});
+
+export function storagePlanDataUSDToJSON(
+  storagePlanDataUSD: StoragePlanDataUSD,
+): string {
+  return JSON.stringify(
+    StoragePlanDataUSD$outboundSchema.parse(storagePlanDataUSD),
+  );
+}
+export function storagePlanDataUSDFromJSON(
+  jsonString: string,
+): SafeParseResult<StoragePlanDataUSD, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StoragePlanDataUSD$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StoragePlanDataUSD' from JSON`,
+  );
+}
+
+/** @internal */
+export const StoragePlanDataBRL$inboundSchema: z.ZodType<
+  StoragePlanDataBRL,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  month: z.number().optional(),
+});
+/** @internal */
+export type StoragePlanDataBRL$Outbound = {
+  month?: number | undefined;
+};
+
+/** @internal */
+export const StoragePlanDataBRL$outboundSchema: z.ZodType<
+  StoragePlanDataBRL$Outbound,
+  z.ZodTypeDef,
+  StoragePlanDataBRL
+> = z.object({
+  month: z.number().optional(),
+});
+
+export function storagePlanDataBRLToJSON(
+  storagePlanDataBRL: StoragePlanDataBRL,
+): string {
+  return JSON.stringify(
+    StoragePlanDataBRL$outboundSchema.parse(storagePlanDataBRL),
+  );
+}
+export function storagePlanDataBRLFromJSON(
+  jsonString: string,
+): SafeParseResult<StoragePlanDataBRL, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StoragePlanDataBRL$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StoragePlanDataBRL' from JSON`,
+  );
+}
+
 /** @internal */
 export const StoragePlanDataPricing$inboundSchema: z.ZodType<
   StoragePlanDataPricing,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  month: z.number().optional(),
+  USD: z.lazy(() => StoragePlanDataUSD$inboundSchema).optional(),
+  BRL: z.lazy(() => StoragePlanDataBRL$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "USD": "usd",
+    "BRL": "brl",
+  });
 });
 /** @internal */
 export type StoragePlanDataPricing$Outbound = {
-  month?: number | undefined;
+  USD?: StoragePlanDataUSD$Outbound | undefined;
+  BRL?: StoragePlanDataBRL$Outbound | undefined;
 };
 
 /** @internal */
@@ -57,7 +191,13 @@ export const StoragePlanDataPricing$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   StoragePlanDataPricing
 > = z.object({
-  month: z.number().optional(),
+  usd: z.lazy(() => StoragePlanDataUSD$outboundSchema).optional(),
+  brl: z.lazy(() => StoragePlanDataBRL$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    usd: "USD",
+    brl: "BRL",
+  });
 });
 
 export function storagePlanDataPricingToJSON(
@@ -78,8 +218,8 @@ export function storagePlanDataPricingFromJSON(
 }
 
 /** @internal */
-export const StoragePlanDataAttributes$inboundSchema: z.ZodType<
-  StoragePlanDataAttributes,
+export const StoragePlanDataRegion$inboundSchema: z.ZodType<
+  StoragePlanDataRegion,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -88,12 +228,65 @@ export const StoragePlanDataAttributes$inboundSchema: z.ZodType<
   pricing: z.lazy(() => StoragePlanDataPricing$inboundSchema).optional(),
 });
 /** @internal */
-export type StoragePlanDataAttributes$Outbound = {
+export type StoragePlanDataRegion$Outbound = {
   name?: string | undefined;
   locations?: Array<string> | undefined;
   pricing?: StoragePlanDataPricing$Outbound | undefined;
 };
 
+/** @internal */
+export const StoragePlanDataRegion$outboundSchema: z.ZodType<
+  StoragePlanDataRegion$Outbound,
+  z.ZodTypeDef,
+  StoragePlanDataRegion
+> = z.object({
+  name: z.string().optional(),
+  locations: z.array(z.string()).optional(),
+  pricing: z.lazy(() => StoragePlanDataPricing$outboundSchema).optional(),
+});
+
+export function storagePlanDataRegionToJSON(
+  storagePlanDataRegion: StoragePlanDataRegion,
+): string {
+  return JSON.stringify(
+    StoragePlanDataRegion$outboundSchema.parse(storagePlanDataRegion),
+  );
+}
+export function storagePlanDataRegionFromJSON(
+  jsonString: string,
+): SafeParseResult<StoragePlanDataRegion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StoragePlanDataRegion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StoragePlanDataRegion' from JSON`,
+  );
+}
+
+/** @internal */
+export const StoragePlanDataAttributes$inboundSchema: z.ZodType<
+  StoragePlanDataAttributes,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string().optional(),
+  storage_type: StoragePlanStorageType$inboundSchema.optional(),
+  storage_class: z.nullable(StoragePlanStorageClass$inboundSchema).optional(),
+  regions: z.array(z.lazy(() => StoragePlanDataRegion$inboundSchema))
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "storage_type": "storagePlanStorageType",
+    "storage_class": "storagePlanStorageClass",
+  });
+});
+/** @internal */
+export type StoragePlanDataAttributes$Outbound = {
+  name?: string | undefined;
+  storage_type?: string | undefined;
+  storage_class?: string | null | undefined;
+  regions?: Array<StoragePlanDataRegion$Outbound> | undefined;
+};
+
 /** @internal */
 export const StoragePlanDataAttributes$outboundSchema: z.ZodType<
   StoragePlanDataAttributes$Outbound,
@@ -101,8 +294,16 @@ export const StoragePlanDataAttributes$outboundSchema: z.ZodType<
   StoragePlanDataAttributes
 > = z.object({
   name: z.string().optional(),
-  locations: z.array(z.string()).optional(),
-  pricing: z.lazy(() => StoragePlanDataPricing$outboundSchema).optional(),
+  storagePlanStorageType: StoragePlanStorageType$outboundSchema.optional(),
+  storagePlanStorageClass: z.nullable(StoragePlanStorageClass$outboundSchema)
+    .optional(),
+  regions: z.array(z.lazy(() => StoragePlanDataRegion$outboundSchema))
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    storagePlanStorageType: "storage_type",
+    storagePlanStorageClass: "storage_class",
+  });
 });
 
 export function storagePlanDataAttributesToJSON(