latitudesh-typescript-sdk 0.2.3 → 0.3.0

package/src/models/deployconfig.ts

@@ -20,7 +20,7 @@ export type DeployConfigAttributes = {
   raid?: string | undefined;
   userData?: string | undefined;
   sshKeys?: Array<string> | undefined;
-  partitions?: Array<Partition> | undefined;
+  partitions?: Array<Partition> | null | undefined;
 };
 
 export type DeployConfigData = {
@@ -94,7 +94,8 @@ export const DeployConfigAttributes$inboundSchema: z.ZodType<
   raid: z.string().optional(),
   user_data: z.string().optional(),
   ssh_keys: z.array(z.string()).optional(),
-  partitions: z.array(z.lazy(() => Partition$inboundSchema)).optional(),
+  partitions: z.nullable(z.array(z.lazy(() => Partition$inboundSchema)))
+    .optional(),
 }).transform((v) => {
   return remap$(v, {
     "operating_system": "operatingSystem",
@@ -109,7 +110,7 @@ export type DeployConfigAttributes$Outbound = {
   raid?: string | undefined;
   user_data?: string | undefined;
   ssh_keys?: Array<string> | undefined;
-  partitions?: Array<Partition$Outbound> | undefined;
+  partitions?: Array<Partition$Outbound> | null | undefined;
 };
 
 /** @internal */
@@ -123,7 +124,8 @@ export const DeployConfigAttributes$outboundSchema: z.ZodType<
   raid: z.string().optional(),
   userData: z.string().optional(),
   sshKeys: z.array(z.string()).optional(),
-  partitions: z.array(z.lazy(() => Partition$outboundSchema)).optional(),
+  partitions: z.nullable(z.array(z.lazy(() => Partition$outboundSchema)))
+    .optional(),
 }).transform((v) => {
   return remap$(v, {
     operatingSystem: "operating_system",

package/src/models/elasticip.ts

@@ -0,0 +1,88 @@
+/*
+ * 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 {
+  ElasticIpData,
+  ElasticIpData$inboundSchema,
+  ElasticIpData$Outbound,
+  ElasticIpData$outboundSchema,
+} from "./elasticipdata.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export type ElasticIpMeta = {};
+
+export type ElasticIp = {
+  data?: ElasticIpData | undefined;
+  meta?: ElasticIpMeta | undefined;
+};
+
+/** @internal */
+export const ElasticIpMeta$inboundSchema: z.ZodType<
+  ElasticIpMeta,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+/** @internal */
+export type ElasticIpMeta$Outbound = {};
+
+/** @internal */
+export const ElasticIpMeta$outboundSchema: z.ZodType<
+  ElasticIpMeta$Outbound,
+  z.ZodTypeDef,
+  ElasticIpMeta
+> = z.object({});
+
+export function elasticIpMetaToJSON(elasticIpMeta: ElasticIpMeta): string {
+  return JSON.stringify(ElasticIpMeta$outboundSchema.parse(elasticIpMeta));
+}
+export function elasticIpMetaFromJSON(
+  jsonString: string,
+): SafeParseResult<ElasticIpMeta, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ElasticIpMeta$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ElasticIpMeta' from JSON`,
+  );
+}
+
+/** @internal */
+export const ElasticIp$inboundSchema: z.ZodType<
+  ElasticIp,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: ElasticIpData$inboundSchema.optional(),
+  meta: z.lazy(() => ElasticIpMeta$inboundSchema).optional(),
+});
+/** @internal */
+export type ElasticIp$Outbound = {
+  data?: ElasticIpData$Outbound | undefined;
+  meta?: ElasticIpMeta$Outbound | undefined;
+};
+
+/** @internal */
+export const ElasticIp$outboundSchema: z.ZodType<
+  ElasticIp$Outbound,
+  z.ZodTypeDef,
+  ElasticIp
+> = z.object({
+  data: ElasticIpData$outboundSchema.optional(),
+  meta: z.lazy(() => ElasticIpMeta$outboundSchema).optional(),
+});
+
+export function elasticIpToJSON(elasticIp: ElasticIp): string {
+  return JSON.stringify(ElasticIp$outboundSchema.parse(elasticIp));
+}
+export function elasticIpFromJSON(
+  jsonString: string,
+): SafeParseResult<ElasticIp, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ElasticIp$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ElasticIp' from JSON`,
+  );
+}

package/src/models/elasticipdata.ts

@@ -0,0 +1,462 @@
+/*
+ * 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 ElasticIpDataType = {
+  ElasticIps: "elastic_ips",
+} as const;
+export type ElasticIpDataType = ClosedEnum<typeof ElasticIpDataType>;
+
+/**
+ * The IP address family
+ */
+export const ElasticIpDataFamily = {
+  IPv4: "IPv4",
+} as const;
+/**
+ * The IP address family
+ */
+export type ElasticIpDataFamily = ClosedEnum<typeof ElasticIpDataFamily>;
+
+/**
+ * The routing mode for this Elastic IP
+ */
+export const Mode = {
+  Routed: "routed",
+} as const;
+/**
+ * The routing mode for this Elastic IP
+ */
+export type Mode = ClosedEnum<typeof Mode>;
+
+/**
+ * The current status of the Elastic IP
+ */
+export const ElasticIpDataStatus = {
+  Provisioning: "provisioning",
+  Active: "active",
+  Releasing: "releasing",
+  Error: "error",
+} as const;
+/**
+ * The current status of the Elastic IP
+ */
+export type ElasticIpDataStatus = ClosedEnum<typeof ElasticIpDataStatus>;
+
+/**
+ * The server this Elastic IP is assigned to
+ */
+export type ElasticIpDataServer = {
+  id?: string | undefined;
+  hostname?: string | undefined;
+  primaryIpv4?: string | undefined;
+};
+
+/**
+ * The project this Elastic IP belongs to
+ */
+export type ElasticIpDataProject = {
+  id?: string | undefined;
+  name?: string | undefined;
+  slug?: string | undefined;
+};
+
+export type ElasticIpDataSite = {
+  slug?: string | undefined;
+};
+
+/**
+ * The region where this Elastic IP is located
+ */
+export type ElasticIpDataRegion = {
+  city?: string | undefined;
+  site?: ElasticIpDataSite | undefined;
+};
+
+export type ElasticIpDataAttributes = {
+  /**
+   * The IP address
+   */
+  address?: string | undefined;
+  /**
+   * The IP address family
+   */
+  family?: ElasticIpDataFamily | undefined;
+  /**
+   * The prefix length (e.g., 32 for a single IP)
+   */
+  prefixLength?: number | undefined;
+  /**
+   * The routing mode for this Elastic IP
+   */
+  mode?: Mode | undefined;
+  /**
+   * The current status of the Elastic IP
+   */
+  status?: ElasticIpDataStatus | undefined;
+  /**
+   * The timestamp when the Elastic IP was created
+   */
+  createdAt?: Date | undefined;
+  /**
+   * The server this Elastic IP is assigned to
+   */
+  server?: ElasticIpDataServer | null | undefined;
+  /**
+   * The project this Elastic IP belongs to
+   */
+  project?: ElasticIpDataProject | undefined;
+  /**
+   * The region where this Elastic IP is located
+   */
+  region?: ElasticIpDataRegion | null | undefined;
+};
+
+export type ElasticIpData = {
+  /**
+   * The Elastic IP ID. May be null during initial provisioning.
+   */
+  id?: string | null | undefined;
+  type?: ElasticIpDataType | undefined;
+  attributes?: ElasticIpDataAttributes | undefined;
+};
+
+/** @internal */
+export const ElasticIpDataType$inboundSchema: z.ZodNativeEnum<
+  typeof ElasticIpDataType
+> = z.nativeEnum(ElasticIpDataType);
+/** @internal */
+export const ElasticIpDataType$outboundSchema: z.ZodNativeEnum<
+  typeof ElasticIpDataType
+> = ElasticIpDataType$inboundSchema;
+
+/** @internal */
+export const ElasticIpDataFamily$inboundSchema: z.ZodNativeEnum<
+  typeof ElasticIpDataFamily
+> = z.nativeEnum(ElasticIpDataFamily);
+/** @internal */
+export const ElasticIpDataFamily$outboundSchema: z.ZodNativeEnum<
+  typeof ElasticIpDataFamily
+> = ElasticIpDataFamily$inboundSchema;
+
+/** @internal */
+export const Mode$inboundSchema: z.ZodNativeEnum<typeof Mode> = z.nativeEnum(
+  Mode,
+);
+/** @internal */
+export const Mode$outboundSchema: z.ZodNativeEnum<typeof Mode> =
+  Mode$inboundSchema;
+
+/** @internal */
+export const ElasticIpDataStatus$inboundSchema: z.ZodNativeEnum<
+  typeof ElasticIpDataStatus
+> = z.nativeEnum(ElasticIpDataStatus);
+/** @internal */
+export const ElasticIpDataStatus$outboundSchema: z.ZodNativeEnum<
+  typeof ElasticIpDataStatus
+> = ElasticIpDataStatus$inboundSchema;
+
+/** @internal */
+export const ElasticIpDataServer$inboundSchema: z.ZodType<
+  ElasticIpDataServer,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string().optional(),
+  hostname: z.string().optional(),
+  primary_ipv4: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "primary_ipv4": "primaryIpv4",
+  });
+});
+/** @internal */
+export type ElasticIpDataServer$Outbound = {
+  id?: string | undefined;
+  hostname?: string | undefined;
+  primary_ipv4?: string | undefined;
+};
+
+/** @internal */
+export const ElasticIpDataServer$outboundSchema: z.ZodType<
+  ElasticIpDataServer$Outbound,
+  z.ZodTypeDef,
+  ElasticIpDataServer
+> = z.object({
+  id: z.string().optional(),
+  hostname: z.string().optional(),
+  primaryIpv4: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    primaryIpv4: "primary_ipv4",
+  });
+});
+
+export function elasticIpDataServerToJSON(
+  elasticIpDataServer: ElasticIpDataServer,
+): string {
+  return JSON.stringify(
+    ElasticIpDataServer$outboundSchema.parse(elasticIpDataServer),
+  );
+}
+export function elasticIpDataServerFromJSON(
+  jsonString: string,
+): SafeParseResult<ElasticIpDataServer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ElasticIpDataServer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ElasticIpDataServer' from JSON`,
+  );
+}
+
+/** @internal */
+export const ElasticIpDataProject$inboundSchema: z.ZodType<
+  ElasticIpDataProject,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string().optional(),
+  name: z.string().optional(),
+  slug: z.string().optional(),
+});
+/** @internal */
+export type ElasticIpDataProject$Outbound = {
+  id?: string | undefined;
+  name?: string | undefined;
+  slug?: string | undefined;
+};
+
+/** @internal */
+export const ElasticIpDataProject$outboundSchema: z.ZodType<
+  ElasticIpDataProject$Outbound,
+  z.ZodTypeDef,
+  ElasticIpDataProject
+> = z.object({
+  id: z.string().optional(),
+  name: z.string().optional(),
+  slug: z.string().optional(),
+});
+
+export function elasticIpDataProjectToJSON(
+  elasticIpDataProject: ElasticIpDataProject,
+): string {
+  return JSON.stringify(
+    ElasticIpDataProject$outboundSchema.parse(elasticIpDataProject),
+  );
+}
+export function elasticIpDataProjectFromJSON(
+  jsonString: string,
+): SafeParseResult<ElasticIpDataProject, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ElasticIpDataProject$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ElasticIpDataProject' from JSON`,
+  );
+}
+
+/** @internal */
+export const ElasticIpDataSite$inboundSchema: z.ZodType<
+  ElasticIpDataSite,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  slug: z.string().optional(),
+});
+/** @internal */
+export type ElasticIpDataSite$Outbound = {
+  slug?: string | undefined;
+};
+
+/** @internal */
+export const ElasticIpDataSite$outboundSchema: z.ZodType<
+  ElasticIpDataSite$Outbound,
+  z.ZodTypeDef,
+  ElasticIpDataSite
+> = z.object({
+  slug: z.string().optional(),
+});
+
+export function elasticIpDataSiteToJSON(
+  elasticIpDataSite: ElasticIpDataSite,
+): string {
+  return JSON.stringify(
+    ElasticIpDataSite$outboundSchema.parse(elasticIpDataSite),
+  );
+}
+export function elasticIpDataSiteFromJSON(
+  jsonString: string,
+): SafeParseResult<ElasticIpDataSite, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ElasticIpDataSite$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ElasticIpDataSite' from JSON`,
+  );
+}
+
+/** @internal */
+export const ElasticIpDataRegion$inboundSchema: z.ZodType<
+  ElasticIpDataRegion,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  city: z.string().optional(),
+  site: z.lazy(() => ElasticIpDataSite$inboundSchema).optional(),
+});
+/** @internal */
+export type ElasticIpDataRegion$Outbound = {
+  city?: string | undefined;
+  site?: ElasticIpDataSite$Outbound | undefined;
+};
+
+/** @internal */
+export const ElasticIpDataRegion$outboundSchema: z.ZodType<
+  ElasticIpDataRegion$Outbound,
+  z.ZodTypeDef,
+  ElasticIpDataRegion
+> = z.object({
+  city: z.string().optional(),
+  site: z.lazy(() => ElasticIpDataSite$outboundSchema).optional(),
+});
+
+export function elasticIpDataRegionToJSON(
+  elasticIpDataRegion: ElasticIpDataRegion,
+): string {
+  return JSON.stringify(
+    ElasticIpDataRegion$outboundSchema.parse(elasticIpDataRegion),
+  );
+}
+export function elasticIpDataRegionFromJSON(
+  jsonString: string,
+): SafeParseResult<ElasticIpDataRegion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ElasticIpDataRegion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ElasticIpDataRegion' from JSON`,
+  );
+}
+
+/** @internal */
+export const ElasticIpDataAttributes$inboundSchema: z.ZodType<
+  ElasticIpDataAttributes,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  address: z.string().optional(),
+  family: ElasticIpDataFamily$inboundSchema.optional(),
+  prefix_length: z.number().int().optional(),
+  mode: Mode$inboundSchema.optional(),
+  status: ElasticIpDataStatus$inboundSchema.optional(),
+  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
+    .optional(),
+  server: z.nullable(z.lazy(() => ElasticIpDataServer$inboundSchema))
+    .optional(),
+  project: z.lazy(() => ElasticIpDataProject$inboundSchema).optional(),
+  region: z.nullable(z.lazy(() => ElasticIpDataRegion$inboundSchema))
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "prefix_length": "prefixLength",
+    "created_at": "createdAt",
+  });
+});
+/** @internal */
+export type ElasticIpDataAttributes$Outbound = {
+  address?: string | undefined;
+  family?: string | undefined;
+  prefix_length?: number | undefined;
+  mode?: string | undefined;
+  status?: string | undefined;
+  created_at?: string | undefined;
+  server?: ElasticIpDataServer$Outbound | null | undefined;
+  project?: ElasticIpDataProject$Outbound | undefined;
+  region?: ElasticIpDataRegion$Outbound | null | undefined;
+};
+
+/** @internal */
+export const ElasticIpDataAttributes$outboundSchema: z.ZodType<
+  ElasticIpDataAttributes$Outbound,
+  z.ZodTypeDef,
+  ElasticIpDataAttributes
+> = z.object({
+  address: z.string().optional(),
+  family: ElasticIpDataFamily$outboundSchema.optional(),
+  prefixLength: z.number().int().optional(),
+  mode: Mode$outboundSchema.optional(),
+  status: ElasticIpDataStatus$outboundSchema.optional(),
+  createdAt: z.date().transform(v => v.toISOString()).optional(),
+  server: z.nullable(z.lazy(() => ElasticIpDataServer$outboundSchema))
+    .optional(),
+  project: z.lazy(() => ElasticIpDataProject$outboundSchema).optional(),
+  region: z.nullable(z.lazy(() => ElasticIpDataRegion$outboundSchema))
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    prefixLength: "prefix_length",
+    createdAt: "created_at",
+  });
+});
+
+export function elasticIpDataAttributesToJSON(
+  elasticIpDataAttributes: ElasticIpDataAttributes,
+): string {
+  return JSON.stringify(
+    ElasticIpDataAttributes$outboundSchema.parse(elasticIpDataAttributes),
+  );
+}
+export function elasticIpDataAttributesFromJSON(
+  jsonString: string,
+): SafeParseResult<ElasticIpDataAttributes, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ElasticIpDataAttributes$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ElasticIpDataAttributes' from JSON`,
+  );
+}
+
+/** @internal */
+export const ElasticIpData$inboundSchema: z.ZodType<
+  ElasticIpData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.nullable(z.string()).optional(),
+  type: ElasticIpDataType$inboundSchema.optional(),
+  attributes: z.lazy(() => ElasticIpDataAttributes$inboundSchema).optional(),
+});
+/** @internal */
+export type ElasticIpData$Outbound = {
+  id?: string | null | undefined;
+  type?: string | undefined;
+  attributes?: ElasticIpDataAttributes$Outbound | undefined;
+};
+
+/** @internal */
+export const ElasticIpData$outboundSchema: z.ZodType<
+  ElasticIpData$Outbound,
+  z.ZodTypeDef,
+  ElasticIpData
+> = z.object({
+  id: z.nullable(z.string()).optional(),
+  type: ElasticIpDataType$outboundSchema.optional(),
+  attributes: z.lazy(() => ElasticIpDataAttributes$outboundSchema).optional(),
+});
+
+export function elasticIpDataToJSON(elasticIpData: ElasticIpData): string {
+  return JSON.stringify(ElasticIpData$outboundSchema.parse(elasticIpData));
+}
+export function elasticIpDataFromJSON(
+  jsonString: string,
+): SafeParseResult<ElasticIpData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ElasticIpData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ElasticIpData' from JSON`,
+  );
+}

package/src/models/elasticips.ts

@@ -0,0 +1,88 @@
+/*
+ * 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 {
+  ElasticIpData,
+  ElasticIpData$inboundSchema,
+  ElasticIpData$Outbound,
+  ElasticIpData$outboundSchema,
+} from "./elasticipdata.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export type ElasticIpsMeta = {};
+
+export type ElasticIps = {
+  data?: Array<ElasticIpData> | undefined;
+  meta?: ElasticIpsMeta | undefined;
+};
+
+/** @internal */
+export const ElasticIpsMeta$inboundSchema: z.ZodType<
+  ElasticIpsMeta,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+/** @internal */
+export type ElasticIpsMeta$Outbound = {};
+
+/** @internal */
+export const ElasticIpsMeta$outboundSchema: z.ZodType<
+  ElasticIpsMeta$Outbound,
+  z.ZodTypeDef,
+  ElasticIpsMeta
+> = z.object({});
+
+export function elasticIpsMetaToJSON(elasticIpsMeta: ElasticIpsMeta): string {
+  return JSON.stringify(ElasticIpsMeta$outboundSchema.parse(elasticIpsMeta));
+}
+export function elasticIpsMetaFromJSON(
+  jsonString: string,
+): SafeParseResult<ElasticIpsMeta, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ElasticIpsMeta$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ElasticIpsMeta' from JSON`,
+  );
+}
+
+/** @internal */
+export const ElasticIps$inboundSchema: z.ZodType<
+  ElasticIps,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.array(ElasticIpData$inboundSchema).optional(),
+  meta: z.lazy(() => ElasticIpsMeta$inboundSchema).optional(),
+});
+/** @internal */
+export type ElasticIps$Outbound = {
+  data?: Array<ElasticIpData$Outbound> | undefined;
+  meta?: ElasticIpsMeta$Outbound | undefined;
+};
+
+/** @internal */
+export const ElasticIps$outboundSchema: z.ZodType<
+  ElasticIps$Outbound,
+  z.ZodTypeDef,
+  ElasticIps
+> = z.object({
+  data: z.array(ElasticIpData$outboundSchema).optional(),
+  meta: z.lazy(() => ElasticIpsMeta$outboundSchema).optional(),
+});
+
+export function elasticIpsToJSON(elasticIps: ElasticIps): string {
+  return JSON.stringify(ElasticIps$outboundSchema.parse(elasticIps));
+}
+export function elasticIpsFromJSON(
+  jsonString: string,
+): SafeParseResult<ElasticIps, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ElasticIps$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ElasticIps' from JSON`,
+  );
+}