latitudesh-typescript-sdk 0.8.5 → 0.8.7

package/src/models/objectstoragedata.ts

@@ -69,6 +69,16 @@ export type ObjectStorageDataRegion = {
   country?: string | null | undefined;
 };
 
+/**
+ * S3 access credentials. Only included when `extra_fields[object_storages]=credentials` is requested and the requesting user is the bucket's creator.
+ */
+export type ObjectStorageDataCredentials = {
+  /**
+   * S3 access key for authentication
+   */
+  accessKey?: string | undefined;
+};
+
 export type ObjectStorageDataAttributes = {
   /**
    * Display name of the object storage
@@ -94,14 +104,6 @@ export type ObjectStorageDataAttributes = {
    * S3-compatible endpoint URL for accessing the bucket
    */
   endpoint?: string | undefined;
-  /**
-   * S3 access key for authentication
-   */
-  accessKey?: string | null | undefined;
-  /**
-   * S3 secret key for authentication
-   */
-  secretKey?: string | null | undefined;
   /**
    * Whether bucket versioning is enabled
    */
@@ -126,6 +128,10 @@ export type ObjectStorageDataAttributes = {
    * Region information where the object storage is located
    */
   region?: ObjectStorageDataRegion | null | undefined;
+  /**
+   * S3 access credentials. Only included when `extra_fields[object_storages]=credentials` is requested and the requesting user is the bucket's creator.
+   */
+  credentials?: ObjectStorageDataCredentials | null | undefined;
   project?: ProjectInclude | undefined;
   team?: TeamInclude | undefined;
 };
@@ -209,6 +215,55 @@ export function objectStorageDataRegionFromJSON(
   );
 }
 
+/** @internal */
+export const ObjectStorageDataCredentials$inboundSchema: z.ZodType<
+  ObjectStorageDataCredentials,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  access_key: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "access_key": "accessKey",
+  });
+});
+/** @internal */
+export type ObjectStorageDataCredentials$Outbound = {
+  access_key?: string | undefined;
+};
+
+/** @internal */
+export const ObjectStorageDataCredentials$outboundSchema: z.ZodType<
+  ObjectStorageDataCredentials$Outbound,
+  z.ZodTypeDef,
+  ObjectStorageDataCredentials
+> = z.object({
+  accessKey: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    accessKey: "access_key",
+  });
+});
+
+export function objectStorageDataCredentialsToJSON(
+  objectStorageDataCredentials: ObjectStorageDataCredentials,
+): string {
+  return JSON.stringify(
+    ObjectStorageDataCredentials$outboundSchema.parse(
+      objectStorageDataCredentials,
+    ),
+  );
+}
+export function objectStorageDataCredentialsFromJSON(
+  jsonString: string,
+): SafeParseResult<ObjectStorageDataCredentials, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ObjectStorageDataCredentials$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ObjectStorageDataCredentials' from JSON`,
+  );
+}
+
 /** @internal */
 export const ObjectStorageDataAttributes$inboundSchema: z.ZodType<
   ObjectStorageDataAttributes,
@@ -223,8 +278,6 @@ export const ObjectStorageDataAttributes$inboundSchema: z.ZodType<
   ).optional(),
   bucket_name: z.string().optional(),
   endpoint: z.string().optional(),
-  access_key: z.nullable(z.string()).optional(),
-  secret_key: z.nullable(z.string()).optional(),
   versioning: z.nullable(z.boolean()).optional(),
   locking: z.nullable(z.boolean()).optional(),
   retention_mode: z.nullable(RetentionMode$inboundSchema).optional(),
@@ -232,6 +285,9 @@ export const ObjectStorageDataAttributes$inboundSchema: z.ZodType<
   source: z.string().optional(),
   region: z.nullable(z.lazy(() => ObjectStorageDataRegion$inboundSchema))
     .optional(),
+  credentials: z.nullable(
+    z.lazy(() => ObjectStorageDataCredentials$inboundSchema),
+  ).optional(),
   project: ProjectInclude$inboundSchema.optional(),
   team: TeamInclude$inboundSchema.optional(),
 }).transform((v) => {
@@ -240,8 +296,6 @@ export const ObjectStorageDataAttributes$inboundSchema: z.ZodType<
     "storage_class": "storageClass",
     "created_at": "createdAt",
     "bucket_name": "bucketName",
-    "access_key": "accessKey",
-    "secret_key": "secretKey",
     "retention_mode": "retentionMode",
     "retention_period": "retentionPeriod",
   });
@@ -254,14 +308,13 @@ export type ObjectStorageDataAttributes$Outbound = {
   created_at?: string | null | undefined;
   bucket_name?: string | undefined;
   endpoint?: string | undefined;
-  access_key?: string | null | undefined;
-  secret_key?: string | null | undefined;
   versioning?: boolean | null | undefined;
   locking?: boolean | null | undefined;
   retention_mode?: string | null | undefined;
   retention_period?: number | null | undefined;
   source?: string | undefined;
   region?: ObjectStorageDataRegion$Outbound | null | undefined;
+  credentials?: ObjectStorageDataCredentials$Outbound | null | undefined;
   project?: ProjectInclude$Outbound | undefined;
   team?: TeamInclude$Outbound | undefined;
 };
@@ -278,8 +331,6 @@ export const ObjectStorageDataAttributes$outboundSchema: z.ZodType<
   createdAt: z.nullable(z.date().transform(v => v.toISOString())).optional(),
   bucketName: z.string().optional(),
   endpoint: z.string().optional(),
-  accessKey: z.nullable(z.string()).optional(),
-  secretKey: z.nullable(z.string()).optional(),
   versioning: z.nullable(z.boolean()).optional(),
   locking: z.nullable(z.boolean()).optional(),
   retentionMode: z.nullable(RetentionMode$outboundSchema).optional(),
@@ -287,6 +338,9 @@ export const ObjectStorageDataAttributes$outboundSchema: z.ZodType<
   source: z.string().optional(),
   region: z.nullable(z.lazy(() => ObjectStorageDataRegion$outboundSchema))
     .optional(),
+  credentials: z.nullable(
+    z.lazy(() => ObjectStorageDataCredentials$outboundSchema),
+  ).optional(),
   project: ProjectInclude$outboundSchema.optional(),
   team: TeamInclude$outboundSchema.optional(),
 }).transform((v) => {
@@ -295,8 +349,6 @@ export const ObjectStorageDataAttributes$outboundSchema: z.ZodType<
     storageClass: "storage_class",
     createdAt: "created_at",
     bucketName: "bucket_name",
-    accessKey: "access_key",
-    secretKey: "secret_key",
     retentionMode: "retention_mode",
     retentionPeriod: "retention_period",
   });

package/src/models/operations/createbaseline.ts

@@ -0,0 +1,246 @@
+/*
+ * 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";
+import * as models from "../index.js";
+
+export const CreateBaselineType2 = {
+  Baselines: "baselines",
+} as const;
+export type CreateBaselineType2 = ClosedEnum<typeof CreateBaselineType2>;
+
+/**
+ * Expected BIOS settings, keyed by setting id
+ */
+export type Bios2 = {};
+
+export type CreateBaselineAttributes2 = {
+  /**
+   * Name of the baseline
+   */
+  name?: string | undefined;
+  /**
+   * Description of the baseline
+   */
+  description?: string | null | undefined;
+  /**
+   * Slug of the plan this baseline applies to
+   */
+  plan?: string | undefined;
+  /**
+   * SSH keys the baseline expects on the server
+   */
+  sshKeyIds?: Array<string> | undefined;
+  /**
+   * User data the baseline expects to run on first boot
+   */
+  userDataId?: string | null | undefined;
+  /**
+   * Expected disk layout
+   */
+  diskLayout?: Array<models.BaselineDiskLayoutGroup> | undefined;
+  /**
+   * Expected BIOS settings, keyed by setting id
+   */
+  bios?: Bios2 | undefined;
+};
+
+export type CreateBaselineData2 = {
+  type?: CreateBaselineType2 | undefined;
+  attributes?: CreateBaselineAttributes2 | undefined;
+};
+
+export type CreateBaselineRequest = {
+  data?: CreateBaselineData2 | undefined;
+};
+
+/** @internal */
+export const CreateBaselineType2$inboundSchema: z.ZodNativeEnum<
+  typeof CreateBaselineType2
+> = z.nativeEnum(CreateBaselineType2);
+/** @internal */
+export const CreateBaselineType2$outboundSchema: z.ZodNativeEnum<
+  typeof CreateBaselineType2
+> = CreateBaselineType2$inboundSchema;
+
+/** @internal */
+export const Bios2$inboundSchema: z.ZodType<Bios2, z.ZodTypeDef, unknown> = z
+  .object({});
+/** @internal */
+export type Bios2$Outbound = {};
+
+/** @internal */
+export const Bios2$outboundSchema: z.ZodType<
+  Bios2$Outbound,
+  z.ZodTypeDef,
+  Bios2
+> = z.object({});
+
+export function bios2ToJSON(bios2: Bios2): string {
+  return JSON.stringify(Bios2$outboundSchema.parse(bios2));
+}
+export function bios2FromJSON(
+  jsonString: string,
+): SafeParseResult<Bios2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Bios2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Bios2' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateBaselineAttributes2$inboundSchema: z.ZodType<
+  CreateBaselineAttributes2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string().optional(),
+  description: z.nullable(z.string()).optional(),
+  plan: z.string().optional(),
+  ssh_key_ids: z.array(z.string()).optional(),
+  user_data_id: z.nullable(z.string()).optional(),
+  disk_layout: z.array(models.BaselineDiskLayoutGroup$inboundSchema).optional(),
+  bios: z.lazy(() => Bios2$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "ssh_key_ids": "sshKeyIds",
+    "user_data_id": "userDataId",
+    "disk_layout": "diskLayout",
+  });
+});
+/** @internal */
+export type CreateBaselineAttributes2$Outbound = {
+  name?: string | undefined;
+  description?: string | null | undefined;
+  plan?: string | undefined;
+  ssh_key_ids?: Array<string> | undefined;
+  user_data_id?: string | null | undefined;
+  disk_layout?: Array<models.BaselineDiskLayoutGroup$Outbound> | undefined;
+  bios?: Bios2$Outbound | undefined;
+};
+
+/** @internal */
+export const CreateBaselineAttributes2$outboundSchema: z.ZodType<
+  CreateBaselineAttributes2$Outbound,
+  z.ZodTypeDef,
+  CreateBaselineAttributes2
+> = z.object({
+  name: z.string().optional(),
+  description: z.nullable(z.string()).optional(),
+  plan: z.string().optional(),
+  sshKeyIds: z.array(z.string()).optional(),
+  userDataId: z.nullable(z.string()).optional(),
+  diskLayout: z.array(models.BaselineDiskLayoutGroup$outboundSchema).optional(),
+  bios: z.lazy(() => Bios2$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    sshKeyIds: "ssh_key_ids",
+    userDataId: "user_data_id",
+    diskLayout: "disk_layout",
+  });
+});
+
+export function createBaselineAttributes2ToJSON(
+  createBaselineAttributes2: CreateBaselineAttributes2,
+): string {
+  return JSON.stringify(
+    CreateBaselineAttributes2$outboundSchema.parse(createBaselineAttributes2),
+  );
+}
+export function createBaselineAttributes2FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateBaselineAttributes2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateBaselineAttributes2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateBaselineAttributes2' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateBaselineData2$inboundSchema: z.ZodType<
+  CreateBaselineData2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: CreateBaselineType2$inboundSchema.optional(),
+  attributes: z.lazy(() => CreateBaselineAttributes2$inboundSchema).optional(),
+});
+/** @internal */
+export type CreateBaselineData2$Outbound = {
+  type?: string | undefined;
+  attributes?: CreateBaselineAttributes2$Outbound | undefined;
+};
+
+/** @internal */
+export const CreateBaselineData2$outboundSchema: z.ZodType<
+  CreateBaselineData2$Outbound,
+  z.ZodTypeDef,
+  CreateBaselineData2
+> = z.object({
+  type: CreateBaselineType2$outboundSchema.optional(),
+  attributes: z.lazy(() => CreateBaselineAttributes2$outboundSchema).optional(),
+});
+
+export function createBaselineData2ToJSON(
+  createBaselineData2: CreateBaselineData2,
+): string {
+  return JSON.stringify(
+    CreateBaselineData2$outboundSchema.parse(createBaselineData2),
+  );
+}
+export function createBaselineData2FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateBaselineData2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateBaselineData2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateBaselineData2' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateBaselineRequest$inboundSchema: z.ZodType<
+  CreateBaselineRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.lazy(() => CreateBaselineData2$inboundSchema).optional(),
+});
+/** @internal */
+export type CreateBaselineRequest$Outbound = {
+  data?: CreateBaselineData2$Outbound | undefined;
+};
+
+/** @internal */
+export const CreateBaselineRequest$outboundSchema: z.ZodType<
+  CreateBaselineRequest$Outbound,
+  z.ZodTypeDef,
+  CreateBaselineRequest
+> = z.object({
+  data: z.lazy(() => CreateBaselineData2$outboundSchema).optional(),
+});
+
+export function createBaselineRequestToJSON(
+  createBaselineRequest: CreateBaselineRequest,
+): string {
+  return JSON.stringify(
+    CreateBaselineRequest$outboundSchema.parse(createBaselineRequest),
+  );
+}
+export function createBaselineRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateBaselineRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateBaselineRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateBaselineRequest' from JSON`,
+  );
+}

package/src/models/operations/createelasticipbgpsession.ts

@@ -0,0 +1,69 @@
+/*
+ * 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 { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import * as models from "../index.js";
+
+export type CreateElasticIpBgpSessionRequest = {
+  elasticIpId: string;
+  createBgpSession: models.CreateBgpSession;
+};
+
+/** @internal */
+export const CreateElasticIpBgpSessionRequest$inboundSchema: z.ZodType<
+  CreateElasticIpBgpSessionRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  elastic_ip_id: z.string(),
+  create_bgp_session: models.CreateBgpSession$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "elastic_ip_id": "elasticIpId",
+    "create_bgp_session": "createBgpSession",
+  });
+});
+/** @internal */
+export type CreateElasticIpBgpSessionRequest$Outbound = {
+  elastic_ip_id: string;
+  create_bgp_session: models.CreateBgpSession$Outbound;
+};
+
+/** @internal */
+export const CreateElasticIpBgpSessionRequest$outboundSchema: z.ZodType<
+  CreateElasticIpBgpSessionRequest$Outbound,
+  z.ZodTypeDef,
+  CreateElasticIpBgpSessionRequest
+> = z.object({
+  elasticIpId: z.string(),
+  createBgpSession: models.CreateBgpSession$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    elasticIpId: "elastic_ip_id",
+    createBgpSession: "create_bgp_session",
+  });
+});
+
+export function createElasticIpBgpSessionRequestToJSON(
+  createElasticIpBgpSessionRequest: CreateElasticIpBgpSessionRequest,
+): string {
+  return JSON.stringify(
+    CreateElasticIpBgpSessionRequest$outboundSchema.parse(
+      createElasticIpBgpSessionRequest,
+    ),
+  );
+}
+export function createElasticIpBgpSessionRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateElasticIpBgpSessionRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateElasticIpBgpSessionRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateElasticIpBgpSessionRequest' from JSON`,
+  );
+}

package/src/models/operations/createserver.ts

@@ -157,23 +157,23 @@ export type CreateServerAttributes2 = {
   /**
    * The project (ID or Slug) to deploy the server
    */
-  project?: string | undefined;
+  project: string;
   /**
    * The plan slug to choose server from, defining the specs the server will have
    */
-  plan?: Plan2 | undefined;
+  plan: Plan2;
   /**
    * The site slug to deploy the server
    */
-  site?: CreateServerSite2 | undefined;
+  site: CreateServerSite2;
   /**
    * The operating system slug for the new server
    */
-  operatingSystem?: CreateServerOperatingSystem2 | undefined;
+  operatingSystem: CreateServerOperatingSystem2;
   /**
    * The server hostname
    */
-  hostname?: string | undefined;
+  hostname: string;
   /**
    * SSH Keys to set on the server
    */
@@ -360,11 +360,11 @@ export const CreateServerAttributes2$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  project: z.string().optional(),
-  plan: Plan2$inboundSchema.optional(),
-  site: CreateServerSite2$inboundSchema.optional(),
-  operating_system: CreateServerOperatingSystem2$inboundSchema.optional(),
-  hostname: z.string().optional(),
+  project: z.string(),
+  plan: Plan2$inboundSchema,
+  site: CreateServerSite2$inboundSchema,
+  operating_system: CreateServerOperatingSystem2$inboundSchema,
+  hostname: z.string(),
   ssh_keys: z.nullable(z.array(z.string())).optional(),
   user_data: z.nullable(z.string()).optional(),
   raid: z.nullable(CreateServerRaid2$inboundSchema).optional(),
@@ -385,11 +385,11 @@ export const CreateServerAttributes2$inboundSchema: z.ZodType<
 });
 /** @internal */
 export type CreateServerAttributes2$Outbound = {
-  project?: string | undefined;
-  plan?: string | undefined;
-  site?: string | undefined;
-  operating_system?: string | undefined;
-  hostname?: string | undefined;
+  project: string;
+  plan: string;
+  site: string;
+  operating_system: string;
+  hostname: string;
   ssh_keys?: Array<string> | null | undefined;
   user_data?: string | null | undefined;
   raid?: string | null | undefined;
@@ -405,11 +405,11 @@ export const CreateServerAttributes2$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   CreateServerAttributes2
 > = z.object({
-  project: z.string().optional(),
-  plan: Plan2$outboundSchema.optional(),
-  site: CreateServerSite2$outboundSchema.optional(),
-  operatingSystem: CreateServerOperatingSystem2$outboundSchema.optional(),
-  hostname: z.string().optional(),
+  project: z.string(),
+  plan: Plan2$outboundSchema,
+  site: CreateServerSite2$outboundSchema,
+  operatingSystem: CreateServerOperatingSystem2$outboundSchema,
+  hostname: z.string(),
   sshKeys: z.nullable(z.array(z.string())).optional(),
   userData: z.nullable(z.string()).optional(),
   raid: z.nullable(CreateServerRaid2$outboundSchema).optional(),

package/src/models/operations/createserveroutofband.ts

@@ -20,7 +20,7 @@ export type CreateServerOutOfBandAttributes2 = {
   /**
    * SSH Key ID to set for out of band
    */
-  sshKeyId?: string | undefined;
+  sshKeyId: string;
 };
 
 export type CreateServerOutOfBandData2 = {
@@ -52,7 +52,7 @@ export const CreateServerOutOfBandAttributes2$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  ssh_key_id: z.string().optional(),
+  ssh_key_id: z.string(),
 }).transform((v) => {
   return remap$(v, {
     "ssh_key_id": "sshKeyId",
@@ -60,7 +60,7 @@ export const CreateServerOutOfBandAttributes2$inboundSchema: z.ZodType<
 });
 /** @internal */
 export type CreateServerOutOfBandAttributes2$Outbound = {
-  ssh_key_id?: string | undefined;
+  ssh_key_id: string;
 };
 
 /** @internal */
@@ -69,7 +69,7 @@ export const CreateServerOutOfBandAttributes2$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   CreateServerOutOfBandAttributes2
 > = z.object({
-  sshKeyId: z.string().optional(),
+  sshKeyId: z.string(),
 }).transform((v) => {
   return remap$(v, {
     sshKeyId: "ssh_key_id",