latitudesh-typescript-sdk 0.6.3 → 0.7.0

package/src/models/virtualnetworkassignments.ts

@@ -6,6 +6,12 @@ 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 {
+  PaginationMeta,
+  PaginationMeta$inboundSchema,
+  PaginationMeta$Outbound,
+  PaginationMeta$outboundSchema,
+} from "./paginationmeta.js";
 import {
   VirtualNetworkAssignmentData,
   VirtualNetworkAssignmentData$inboundSchema,
@@ -13,48 +19,11 @@ import {
   VirtualNetworkAssignmentData$outboundSchema,
 } from "./virtualnetworkassignmentdata.js";
 
-export type VirtualNetworkAssignmentsMeta = {};
-
 export type VirtualNetworkAssignments = {
   data?: Array<VirtualNetworkAssignmentData> | undefined;
-  meta?: VirtualNetworkAssignmentsMeta | undefined;
+  meta?: PaginationMeta | undefined;
 };
 
-/** @internal */
-export const VirtualNetworkAssignmentsMeta$inboundSchema: z.ZodType<
-  VirtualNetworkAssignmentsMeta,
-  z.ZodTypeDef,
-  unknown
-> = z.object({});
-/** @internal */
-export type VirtualNetworkAssignmentsMeta$Outbound = {};
-
-/** @internal */
-export const VirtualNetworkAssignmentsMeta$outboundSchema: z.ZodType<
-  VirtualNetworkAssignmentsMeta$Outbound,
-  z.ZodTypeDef,
-  VirtualNetworkAssignmentsMeta
-> = z.object({});
-
-export function virtualNetworkAssignmentsMetaToJSON(
-  virtualNetworkAssignmentsMeta: VirtualNetworkAssignmentsMeta,
-): string {
-  return JSON.stringify(
-    VirtualNetworkAssignmentsMeta$outboundSchema.parse(
-      virtualNetworkAssignmentsMeta,
-    ),
-  );
-}
-export function virtualNetworkAssignmentsMetaFromJSON(
-  jsonString: string,
-): SafeParseResult<VirtualNetworkAssignmentsMeta, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => VirtualNetworkAssignmentsMeta$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'VirtualNetworkAssignmentsMeta' from JSON`,
-  );
-}
-
 /** @internal */
 export const VirtualNetworkAssignments$inboundSchema: z.ZodType<
   VirtualNetworkAssignments,
@@ -62,12 +31,12 @@ export const VirtualNetworkAssignments$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   data: z.array(VirtualNetworkAssignmentData$inboundSchema).optional(),
-  meta: z.lazy(() => VirtualNetworkAssignmentsMeta$inboundSchema).optional(),
+  meta: PaginationMeta$inboundSchema.optional(),
 });
 /** @internal */
 export type VirtualNetworkAssignments$Outbound = {
   data?: Array<VirtualNetworkAssignmentData$Outbound> | undefined;
-  meta?: VirtualNetworkAssignmentsMeta$Outbound | undefined;
+  meta?: PaginationMeta$Outbound | undefined;
 };
 
 /** @internal */
@@ -77,7 +46,7 @@ export const VirtualNetworkAssignments$outboundSchema: z.ZodType<
   VirtualNetworkAssignments
 > = z.object({
   data: z.array(VirtualNetworkAssignmentData$outboundSchema).optional(),
-  meta: z.lazy(() => VirtualNetworkAssignmentsMeta$outboundSchema).optional(),
+  meta: PaginationMeta$outboundSchema.optional(),
 });
 
 export function virtualNetworkAssignmentsToJSON(

package/src/models/virtualnetworkdata.ts

@@ -36,8 +36,8 @@ export type VirtualNetworkDataRegion = {
 export type VirtualNetworkDataTag = {
   id?: string | undefined;
   name?: string | undefined;
-  description?: string | undefined;
-  color?: string | undefined;
+  description?: string | null | undefined;
+  color?: string | null | undefined;
 };
 
 export type VirtualNetworkDataAttributes = {
@@ -182,15 +182,15 @@ export const VirtualNetworkDataTag$inboundSchema: z.ZodType<
 > = z.object({
   id: z.string().optional(),
   name: z.string().optional(),
-  description: z.string().optional(),
-  color: z.string().optional(),
+  description: z.nullable(z.string()).optional(),
+  color: z.nullable(z.string()).optional(),
 });
 /** @internal */
 export type VirtualNetworkDataTag$Outbound = {
   id?: string | undefined;
   name?: string | undefined;
-  description?: string | undefined;
-  color?: string | undefined;
+  description?: string | null | undefined;
+  color?: string | null | undefined;
 };
 
 /** @internal */
@@ -201,8 +201,8 @@ export const VirtualNetworkDataTag$outboundSchema: z.ZodType<
 > = z.object({
   id: z.string().optional(),
   name: z.string().optional(),
-  description: z.string().optional(),
-  color: z.string().optional(),
+  description: z.nullable(z.string()).optional(),
+  color: z.nullable(z.string()).optional(),
 });
 
 export function virtualNetworkDataTagToJSON(

package/src/models/virtualnetworks.ts

@@ -6,6 +6,12 @@ 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 {
+  PaginationMeta,
+  PaginationMeta$inboundSchema,
+  PaginationMeta$Outbound,
+  PaginationMeta$outboundSchema,
+} from "./paginationmeta.js";
 import {
   VirtualNetworkData,
   VirtualNetworkData$inboundSchema,
@@ -13,46 +19,11 @@ import {
   VirtualNetworkData$outboundSchema,
 } from "./virtualnetworkdata.js";
 
-export type VirtualNetworksMeta = {};
-
 export type VirtualNetworks = {
   data?: Array<VirtualNetworkData> | undefined;
-  meta?: VirtualNetworksMeta | undefined;
+  meta?: PaginationMeta | undefined;
 };
 
-/** @internal */
-export const VirtualNetworksMeta$inboundSchema: z.ZodType<
-  VirtualNetworksMeta,
-  z.ZodTypeDef,
-  unknown
-> = z.object({});
-/** @internal */
-export type VirtualNetworksMeta$Outbound = {};
-
-/** @internal */
-export const VirtualNetworksMeta$outboundSchema: z.ZodType<
-  VirtualNetworksMeta$Outbound,
-  z.ZodTypeDef,
-  VirtualNetworksMeta
-> = z.object({});
-
-export function virtualNetworksMetaToJSON(
-  virtualNetworksMeta: VirtualNetworksMeta,
-): string {
-  return JSON.stringify(
-    VirtualNetworksMeta$outboundSchema.parse(virtualNetworksMeta),
-  );
-}
-export function virtualNetworksMetaFromJSON(
-  jsonString: string,
-): SafeParseResult<VirtualNetworksMeta, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => VirtualNetworksMeta$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'VirtualNetworksMeta' from JSON`,
-  );
-}
-
 /** @internal */
 export const VirtualNetworks$inboundSchema: z.ZodType<
   VirtualNetworks,
@@ -60,12 +31,12 @@ export const VirtualNetworks$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   data: z.array(VirtualNetworkData$inboundSchema).optional(),
-  meta: z.lazy(() => VirtualNetworksMeta$inboundSchema).optional(),
+  meta: PaginationMeta$inboundSchema.optional(),
 });
 /** @internal */
 export type VirtualNetworks$Outbound = {
   data?: Array<VirtualNetworkData$Outbound> | undefined;
-  meta?: VirtualNetworksMeta$Outbound | undefined;
+  meta?: PaginationMeta$Outbound | undefined;
 };
 
 /** @internal */
@@ -75,7 +46,7 @@ export const VirtualNetworks$outboundSchema: z.ZodType<
   VirtualNetworks
 > = z.object({
   data: z.array(VirtualNetworkData$outboundSchema).optional(),
-  meta: z.lazy(() => VirtualNetworksMeta$outboundSchema).optional(),
+  meta: PaginationMeta$outboundSchema.optional(),
 });
 
 export function virtualNetworksToJSON(

package/src/sdk/plans.ts

@@ -4,6 +4,7 @@
 
 import { plansGet } from "../funcs/plansGet.js";
 import { plansGetBandwidth } from "../funcs/plansGetBandwidth.js";
+import { plansGetManagedDatabasePlans } from "../funcs/plansGetManagedDatabasePlans.js";
 import { plansList } from "../funcs/plansList.js";
 import { plansListStorage } from "../funcs/plansListStorage.js";
 import { plansUpdateBandwidth } from "../funcs/plansUpdateBandwidth.js";
@@ -98,4 +99,16 @@ export class Plans extends ClientSDK {
       options,
     ));
   }
+
+  /**
+   * List managed database plans
+   */
+  async getManagedDatabasePlans(
+    options?: RequestOptions,
+  ): Promise<models.ManagedDatabasePlans> {
+    return unwrapAsync(plansGetManagedDatabasePlans(
+      this,
+      options,
+    ));
+  }
 }

package/src/sdk/sdk.ts

@@ -27,6 +27,8 @@ import { Teams } from "./teams.js";
 import { Traffic } from "./traffic.js";
 import { UserData } from "./userdata.js";
 import { UserProfile } from "./userprofile.js";
+import { VirtualMachineBackups } from "./virtualmachinebackups.js";
+import { VirtualMachineRestores } from "./virtualmachinerestores.js";
 import { VirtualMachines } from "./virtualmachines.js";
 import { VirtualNetworks } from "./virtualnetworks.js";
 import { VpnSessions } from "./vpnsessions.js";
@@ -152,6 +154,20 @@ export class Latitudesh extends ClientSDK {
     return (this._virtualMachines ??= new VirtualMachines(this._options));
   }
 
+  private _virtualMachineBackups?: VirtualMachineBackups;
+  get virtualMachineBackups(): VirtualMachineBackups {
+    return (this._virtualMachineBackups ??= new VirtualMachineBackups(
+      this._options,
+    ));
+  }
+
+  private _virtualMachineRestores?: VirtualMachineRestores;
+  get virtualMachineRestores(): VirtualMachineRestores {
+    return (this._virtualMachineRestores ??= new VirtualMachineRestores(
+      this._options,
+    ));
+  }
+
   private _privateNetworks?: PrivateNetworks;
   get privateNetworks(): PrivateNetworks {
     return (this._privateNetworks ??= new PrivateNetworks(this._options));

package/src/sdk/virtualmachinebackups.ts

@@ -0,0 +1,113 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { virtualMachineBackupsCreate } from "../funcs/virtualMachineBackupsCreate.js";
+import { virtualMachineBackupsCreateForVirtualMachine } from "../funcs/virtualMachineBackupsCreateForVirtualMachine.js";
+import { virtualMachineBackupsDelete } from "../funcs/virtualMachineBackupsDelete.js";
+import { virtualMachineBackupsGet } from "../funcs/virtualMachineBackupsGet.js";
+import { virtualMachineBackupsList } from "../funcs/virtualMachineBackupsList.js";
+import { virtualMachineBackupsListForVirtualMachine } from "../funcs/virtualMachineBackupsListForVirtualMachine.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";
+
+export class VirtualMachineBackups extends ClientSDK {
+  /**
+   * List a VM's backups
+   *
+   * @remarks
+   * Lists the backups of the given Virtual Machine.
+   */
+  async listForVirtualMachine(
+    request: operations.ListVirtualMachineScopedBackupsRequest,
+    options?: RequestOptions,
+  ): Promise<models.VirtualMachineBackups> {
+    return unwrapAsync(virtualMachineBackupsListForVirtualMachine(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Create VM backup
+   *
+   * @remarks
+   * Triggers a backup of the given Virtual Machine.
+   */
+  async createForVirtualMachine(
+    request: operations.CreateVirtualMachineBackupRequest,
+    options?: RequestOptions,
+  ): Promise<models.VirtualMachineBackup> {
+    return unwrapAsync(virtualMachineBackupsCreateForVirtualMachine(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * List all VM backups
+   *
+   * @remarks
+   * Lists every backup that belongs to the authenticated team.
+   */
+  async list(
+    options?: RequestOptions,
+  ): Promise<models.VirtualMachineBackups> {
+    return unwrapAsync(virtualMachineBackupsList(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Create VM backup (top-level)
+   *
+   * @remarks
+   * Triggers a backup of the Virtual Machine referenced in the body.
+   */
+  async create(
+    request: models.VirtualMachineBackupPayload,
+    options?: RequestOptions,
+  ): Promise<models.VirtualMachineBackup> {
+    return unwrapAsync(virtualMachineBackupsCreate(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get VM backup
+   */
+  async get(
+    request: operations.GetVirtualMachineBackupRequest,
+    options?: RequestOptions,
+  ): Promise<models.VirtualMachineBackup> {
+    return unwrapAsync(virtualMachineBackupsGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete VM backup
+   *
+   * @remarks
+   * Archives and deletes a Virtual Machine backup. Work runs asynchronously and returns 202 Accepted. Only `Ready` or `Failed` backups can be deleted, and not while a restore from the backup is in progress.
+   */
+  async delete(
+    request: operations.DeleteVirtualMachineBackupRequest,
+    options?: RequestOptions,
+  ): Promise<models.VirtualMachineBackup> {
+    return unwrapAsync(virtualMachineBackupsDelete(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/virtualmachinerestores.ts

@@ -0,0 +1,113 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { virtualMachineRestoresCreate } from "../funcs/virtualMachineRestoresCreate.js";
+import { virtualMachineRestoresCreateForVirtualMachineBackup } from "../funcs/virtualMachineRestoresCreateForVirtualMachineBackup.js";
+import { virtualMachineRestoresGet } from "../funcs/virtualMachineRestoresGet.js";
+import { virtualMachineRestoresList } from "../funcs/virtualMachineRestoresList.js";
+import { virtualMachineRestoresListForBackup } from "../funcs/virtualMachineRestoresListForBackup.js";
+import { virtualMachineRestoresListForVirtualMachineBackup } from "../funcs/virtualMachineRestoresListForVirtualMachineBackup.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";
+
+export class VirtualMachineRestores extends ClientSDK {
+  /**
+   * List a backup's restores
+   *
+   * @remarks
+   * Lists the restores created from the given backup.
+   */
+  async listForVirtualMachineBackup(
+    request: operations.ListVirtualMachineScopedRestoresRequest,
+    options?: RequestOptions,
+  ): Promise<models.VirtualMachineRestores> {
+    return unwrapAsync(virtualMachineRestoresListForVirtualMachineBackup(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Create VM restore
+   *
+   * @remarks
+   * Restores a backup into a new Virtual Machine. Optionally accepts a `name` for the restored VM and a target `site` slug to restore into another region.
+   */
+  async createForVirtualMachineBackup(
+    request: operations.CreateVirtualMachineRestoreRequest,
+    options?: RequestOptions,
+  ): Promise<models.VirtualMachineRestore> {
+    return unwrapAsync(virtualMachineRestoresCreateForVirtualMachineBackup(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * List a backup's restores (top-level backup path)
+   *
+   * @remarks
+   * Lists the restores created from the given backup, reached via the top-level backup path.
+   */
+  async listForBackup(
+    request: operations.ListBackupRestoresRequest,
+    options?: RequestOptions,
+  ): Promise<models.VirtualMachineRestores> {
+    return unwrapAsync(virtualMachineRestoresListForBackup(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * List all VM restores
+   *
+   * @remarks
+   * Lists every restore that belongs to the authenticated team.
+   */
+  async list(
+    options?: RequestOptions,
+  ): Promise<models.VirtualMachineRestores> {
+    return unwrapAsync(virtualMachineRestoresList(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Create VM restore (flat)
+   *
+   * @remarks
+   * Restores the backup referenced in the body into a new Virtual Machine. Optionally accepts a `name` for the restored VM and a target `site` slug to restore into another region.
+   */
+  async create(
+    request: models.VirtualMachineRestorePayload,
+    options?: RequestOptions,
+  ): Promise<models.VirtualMachineRestore> {
+    return unwrapAsync(virtualMachineRestoresCreate(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get VM restore
+   */
+  async get(
+    request: operations.GetVirtualMachineRestoreRequest,
+    options?: RequestOptions,
+  ): Promise<models.VirtualMachineRestore> {
+    return unwrapAsync(virtualMachineRestoresGet(
+      this,
+      request,
+      options,
+    ));
+  }
+}