@alienplatform/platform-api 3.3.12 → 3.3.13

package/src/models/newdeploymentrequest.ts

@@ -168,7 +168,29 @@ export type NewDeploymentRequestEnvironmentInfoUnion =
   | NewDeploymentRequestEnvironmentInfoTest
   | any;
 
+/**
+ * Failure-domain policy selected for a compute pool.
+ */
+export type NewDeploymentRequestFailureDomains2 = {
+  /**
+   * Concrete provider domains selected during setup.
+   *
+   * @remarks
+   * Empty delegates deterministic selection to the provider setup implementation.
+   */
+  selectedFailureDomains?: Array<string> | undefined;
+  /**
+   * Number of distinct failure domains across which new stateful replicas may be spread.
+   */
+  spread: number;
+};
+
+export type NewDeploymentRequestFailureDomainsUnion2 =
+  | NewDeploymentRequestFailureDomains2
+  | any;
+
 export type NewDeploymentRequestPoolsAutoscale = {
+  failureDomains?: NewDeploymentRequestFailureDomains2 | any | null | undefined;
   /**
    * Provider machine type selected for this deployment.
    */
@@ -184,7 +206,29 @@ export type NewDeploymentRequestPoolsAutoscale = {
   mode: "autoscale";
 };
 
+/**
+ * Failure-domain policy selected for a compute pool.
+ */
+export type NewDeploymentRequestFailureDomains1 = {
+  /**
+   * Concrete provider domains selected during setup.
+   *
+   * @remarks
+   * Empty delegates deterministic selection to the provider setup implementation.
+   */
+  selectedFailureDomains?: Array<string> | undefined;
+  /**
+   * Number of distinct failure domains across which new stateful replicas may be spread.
+   */
+  spread: number;
+};
+
+export type NewDeploymentRequestFailureDomainsUnion1 =
+  | NewDeploymentRequestFailureDomains1
+  | any;
+
 export type NewDeploymentRequestPoolsFixed = {
+  failureDomains?: NewDeploymentRequestFailureDomains1 | any | null | undefined;
   /**
    * Provider machine type selected for this deployment.
    */
@@ -1307,6 +1351,23 @@ export const InitialDesiredRelease = {
  */
 export type InitialDesiredRelease = ClosedEnum<typeof InitialDesiredRelease>;
 
+/**
+ * Customer setup item selected from this deployment-group token.
+ */
+export const NewDeploymentRequestSetupItem = {
+  Deployment: "deployment",
+  Models: "models",
+  Keys: "keys",
+  Bucket: "bucket",
+  Registry: "registry",
+} as const;
+/**
+ * Customer setup item selected from this deployment-group token.
+ */
+export type NewDeploymentRequestSetupItem = ClosedEnum<
+  typeof NewDeploymentRequestSetupItem
+>;
+
 /**
  * Request schema for creating a new deployment
  */
@@ -1378,6 +1439,14 @@ export type NewDeploymentRequest = {
    * Desired-release selection for a new deployment. Use none to register an environment without initially requesting a release; later updates can assign one.
    */
   initialDesiredRelease?: InitialDesiredRelease | undefined;
+  /**
+   * Release channel followed while this deployment is not pinned.
+   */
+  releaseChannel?: string | undefined;
+  /**
+   * Customer setup item selected from this deployment-group token.
+   */
+  setupItem?: NewDeploymentRequestSetupItem | undefined;
 };
 
 /** @internal */
@@ -1587,8 +1656,63 @@ export function newDeploymentRequestEnvironmentInfoUnionToJSON(
   );
 }
 
+/** @internal */
+export type NewDeploymentRequestFailureDomains2$Outbound = {
+  selectedFailureDomains?: Array<string> | undefined;
+  spread: number;
+};
+
+/** @internal */
+export const NewDeploymentRequestFailureDomains2$outboundSchema: z.ZodType<
+  NewDeploymentRequestFailureDomains2$Outbound,
+  NewDeploymentRequestFailureDomains2
+> = z.object({
+  selectedFailureDomains: z.array(z.string()).optional(),
+  spread: z.int(),
+});
+
+export function newDeploymentRequestFailureDomains2ToJSON(
+  newDeploymentRequestFailureDomains2: NewDeploymentRequestFailureDomains2,
+): string {
+  return JSON.stringify(
+    NewDeploymentRequestFailureDomains2$outboundSchema.parse(
+      newDeploymentRequestFailureDomains2,
+    ),
+  );
+}
+
+/** @internal */
+export type NewDeploymentRequestFailureDomainsUnion2$Outbound =
+  | NewDeploymentRequestFailureDomains2$Outbound
+  | any;
+
+/** @internal */
+export const NewDeploymentRequestFailureDomainsUnion2$outboundSchema: z.ZodType<
+  NewDeploymentRequestFailureDomainsUnion2$Outbound,
+  NewDeploymentRequestFailureDomainsUnion2
+> = z.union([
+  z.lazy(() => NewDeploymentRequestFailureDomains2$outboundSchema),
+  z.any(),
+]);
+
+export function newDeploymentRequestFailureDomainsUnion2ToJSON(
+  newDeploymentRequestFailureDomainsUnion2:
+    NewDeploymentRequestFailureDomainsUnion2,
+): string {
+  return JSON.stringify(
+    NewDeploymentRequestFailureDomainsUnion2$outboundSchema.parse(
+      newDeploymentRequestFailureDomainsUnion2,
+    ),
+  );
+}
+
 /** @internal */
 export type NewDeploymentRequestPoolsAutoscale$Outbound = {
+  failure_domains?:
+    | NewDeploymentRequestFailureDomains2$Outbound
+    | any
+    | null
+    | undefined;
   machine?: string | null | undefined;
   max: number;
   min: number;
@@ -1600,10 +1724,20 @@ export const NewDeploymentRequestPoolsAutoscale$outboundSchema: z.ZodType<
   NewDeploymentRequestPoolsAutoscale$Outbound,
   NewDeploymentRequestPoolsAutoscale
 > = z.object({
+  failureDomains: z.nullable(
+    z.union([
+      z.lazy(() => NewDeploymentRequestFailureDomains2$outboundSchema),
+      z.any(),
+    ]),
+  ).optional(),
   machine: z.nullable(z.string()).optional(),
   max: z.int(),
   min: z.int(),
   mode: z.literal("autoscale"),
+}).transform((v) => {
+  return remap$(v, {
+    failureDomains: "failure_domains",
+  });
 });
 
 export function newDeploymentRequestPoolsAutoscaleToJSON(
@@ -1616,8 +1750,63 @@ export function newDeploymentRequestPoolsAutoscaleToJSON(
   );
 }
 
+/** @internal */
+export type NewDeploymentRequestFailureDomains1$Outbound = {
+  selectedFailureDomains?: Array<string> | undefined;
+  spread: number;
+};
+
+/** @internal */
+export const NewDeploymentRequestFailureDomains1$outboundSchema: z.ZodType<
+  NewDeploymentRequestFailureDomains1$Outbound,
+  NewDeploymentRequestFailureDomains1
+> = z.object({
+  selectedFailureDomains: z.array(z.string()).optional(),
+  spread: z.int(),
+});
+
+export function newDeploymentRequestFailureDomains1ToJSON(
+  newDeploymentRequestFailureDomains1: NewDeploymentRequestFailureDomains1,
+): string {
+  return JSON.stringify(
+    NewDeploymentRequestFailureDomains1$outboundSchema.parse(
+      newDeploymentRequestFailureDomains1,
+    ),
+  );
+}
+
+/** @internal */
+export type NewDeploymentRequestFailureDomainsUnion1$Outbound =
+  | NewDeploymentRequestFailureDomains1$Outbound
+  | any;
+
+/** @internal */
+export const NewDeploymentRequestFailureDomainsUnion1$outboundSchema: z.ZodType<
+  NewDeploymentRequestFailureDomainsUnion1$Outbound,
+  NewDeploymentRequestFailureDomainsUnion1
+> = z.union([
+  z.lazy(() => NewDeploymentRequestFailureDomains1$outboundSchema),
+  z.any(),
+]);
+
+export function newDeploymentRequestFailureDomainsUnion1ToJSON(
+  newDeploymentRequestFailureDomainsUnion1:
+    NewDeploymentRequestFailureDomainsUnion1,
+): string {
+  return JSON.stringify(
+    NewDeploymentRequestFailureDomainsUnion1$outboundSchema.parse(
+      newDeploymentRequestFailureDomainsUnion1,
+    ),
+  );
+}
+
 /** @internal */
 export type NewDeploymentRequestPoolsFixed$Outbound = {
+  failure_domains?:
+    | NewDeploymentRequestFailureDomains1$Outbound
+    | any
+    | null
+    | undefined;
   machine?: string | null | undefined;
   machines: number;
   mode: "fixed";
@@ -1628,9 +1817,19 @@ export const NewDeploymentRequestPoolsFixed$outboundSchema: z.ZodType<
   NewDeploymentRequestPoolsFixed$Outbound,
   NewDeploymentRequestPoolsFixed
 > = z.object({
+  failureDomains: z.nullable(
+    z.union([
+      z.lazy(() => NewDeploymentRequestFailureDomains1$outboundSchema),
+      z.any(),
+    ]),
+  ).optional(),
   machine: z.nullable(z.string()).optional(),
   machines: z.int(),
   mode: z.literal("fixed"),
+}).transform((v) => {
+  return remap$(v, {
+    failureDomains: "failure_domains",
+  });
 });
 
 export function newDeploymentRequestPoolsFixedToJSON(
@@ -3977,6 +4176,11 @@ export const InitialDesiredRelease$outboundSchema: z.ZodEnum<
   typeof InitialDesiredRelease
 > = z.enum(InitialDesiredRelease);
 
+/** @internal */
+export const NewDeploymentRequestSetupItem$outboundSchema: z.ZodEnum<
+  typeof NewDeploymentRequestSetupItem
+> = z.enum(NewDeploymentRequestSetupItem);
+
 /** @internal */
 export type NewDeploymentRequest$Outbound = {
   name: string;
@@ -4007,6 +4211,8 @@ export type NewDeploymentRequest$Outbound = {
   operatorScope?: string | undefined;
   operatorPermission?: string | undefined;
   initialDesiredRelease: string;
+  releaseChannel: string;
+  setupItem?: string | undefined;
 };
 
 /** @internal */
@@ -4044,6 +4250,8 @@ export const NewDeploymentRequest$outboundSchema: z.ZodType<
   operatorScope: z.string().optional(),
   operatorPermission: z.string().optional(),
   initialDesiredRelease: InitialDesiredRelease$outboundSchema.default("active"),
+  releaseChannel: z.string().default("production"),
+  setupItem: NewDeploymentRequestSetupItem$outboundSchema.optional(),
 });
 
 export function newDeploymentRequestToJSON(

package/src/models/operations/acceptworkspaceinvitation.ts

@@ -0,0 +1,32 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+
+export type AcceptWorkspaceInvitationRequest = {
+  token: string;
+};
+
+/** @internal */
+export type AcceptWorkspaceInvitationRequest$Outbound = {
+  token: string;
+};
+
+/** @internal */
+export const AcceptWorkspaceInvitationRequest$outboundSchema: z.ZodType<
+  AcceptWorkspaceInvitationRequest$Outbound,
+  AcceptWorkspaceInvitationRequest
+> = z.object({
+  token: z.string(),
+});
+
+export function acceptWorkspaceInvitationRequestToJSON(
+  acceptWorkspaceInvitationRequest: AcceptWorkspaceInvitationRequest,
+): string {
+  return JSON.stringify(
+    AcceptWorkspaceInvitationRequest$outboundSchema.parse(
+      acceptWorkspaceInvitationRequest,
+    ),
+  );
+}

package/src/models/operations/applycontainerregistrymanagersnapshot.ts

@@ -0,0 +1,175 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const ApplyContainerRegistryManagerSnapshotStatus = {
+  Ready: "ready",
+  Deleted: "deleted",
+  Failed: "failed",
+} as const;
+export type ApplyContainerRegistryManagerSnapshotStatus = ClosedEnum<
+  typeof ApplyContainerRegistryManagerSnapshotStatus
+>;
+
+export type ApplyContainerRegistryManagerSnapshotRepository = {
+  /**
+   * Unique identifier for the container registry repository.
+   */
+  id: string;
+  status: ApplyContainerRegistryManagerSnapshotStatus;
+  routableUpstreamName: string | null;
+  error: string | null;
+};
+
+export type Verification = {
+  succeeded: boolean;
+  observedAt: Date;
+  error: string | null;
+};
+
+export type ApplyContainerRegistryManagerSnapshotRequestBody = {
+  /**
+   * Unique identifier for the container registry route.
+   */
+  routeId: string;
+  desiredRevision: number;
+  repositories: Array<ApplyContainerRegistryManagerSnapshotRepository>;
+  verification: Verification | null;
+};
+
+export type ApplyContainerRegistryManagerSnapshotRequest = {
+  id: string;
+  requestBody?: ApplyContainerRegistryManagerSnapshotRequestBody | undefined;
+};
+
+/** @internal */
+export const ApplyContainerRegistryManagerSnapshotStatus$outboundSchema:
+  z.ZodEnum<typeof ApplyContainerRegistryManagerSnapshotStatus> = z.enum(
+    ApplyContainerRegistryManagerSnapshotStatus,
+  );
+
+/** @internal */
+export type ApplyContainerRegistryManagerSnapshotRepository$Outbound = {
+  id: string;
+  status: string;
+  routableUpstreamName: string | null;
+  error: string | null;
+};
+
+/** @internal */
+export const ApplyContainerRegistryManagerSnapshotRepository$outboundSchema:
+  z.ZodType<
+    ApplyContainerRegistryManagerSnapshotRepository$Outbound,
+    ApplyContainerRegistryManagerSnapshotRepository
+  > = z.object({
+    id: z.string(),
+    status: ApplyContainerRegistryManagerSnapshotStatus$outboundSchema,
+    routableUpstreamName: z.nullable(z.string()),
+    error: z.nullable(z.string()),
+  });
+
+export function applyContainerRegistryManagerSnapshotRepositoryToJSON(
+  applyContainerRegistryManagerSnapshotRepository:
+    ApplyContainerRegistryManagerSnapshotRepository,
+): string {
+  return JSON.stringify(
+    ApplyContainerRegistryManagerSnapshotRepository$outboundSchema.parse(
+      applyContainerRegistryManagerSnapshotRepository,
+    ),
+  );
+}
+
+/** @internal */
+export type Verification$Outbound = {
+  succeeded: boolean;
+  observedAt: string;
+  error: string | null;
+};
+
+/** @internal */
+export const Verification$outboundSchema: z.ZodType<
+  Verification$Outbound,
+  Verification
+> = z.object({
+  succeeded: z.boolean(),
+  observedAt: z.date().transform(v => v.toISOString()),
+  error: z.nullable(z.string()),
+});
+
+export function verificationToJSON(verification: Verification): string {
+  return JSON.stringify(Verification$outboundSchema.parse(verification));
+}
+
+/** @internal */
+export type ApplyContainerRegistryManagerSnapshotRequestBody$Outbound = {
+  routeId: string;
+  desiredRevision: number;
+  repositories: Array<ApplyContainerRegistryManagerSnapshotRepository$Outbound>;
+  verification: Verification$Outbound | null;
+};
+
+/** @internal */
+export const ApplyContainerRegistryManagerSnapshotRequestBody$outboundSchema:
+  z.ZodType<
+    ApplyContainerRegistryManagerSnapshotRequestBody$Outbound,
+    ApplyContainerRegistryManagerSnapshotRequestBody
+  > = z.object({
+    routeId: z.string(),
+    desiredRevision: z.int(),
+    repositories: z.array(
+      z.lazy(() =>
+        ApplyContainerRegistryManagerSnapshotRepository$outboundSchema
+      ),
+    ),
+    verification: z.nullable(z.lazy(() => Verification$outboundSchema)),
+  });
+
+export function applyContainerRegistryManagerSnapshotRequestBodyToJSON(
+  applyContainerRegistryManagerSnapshotRequestBody:
+    ApplyContainerRegistryManagerSnapshotRequestBody,
+): string {
+  return JSON.stringify(
+    ApplyContainerRegistryManagerSnapshotRequestBody$outboundSchema.parse(
+      applyContainerRegistryManagerSnapshotRequestBody,
+    ),
+  );
+}
+
+/** @internal */
+export type ApplyContainerRegistryManagerSnapshotRequest$Outbound = {
+  id: string;
+  RequestBody?:
+    | ApplyContainerRegistryManagerSnapshotRequestBody$Outbound
+    | undefined;
+};
+
+/** @internal */
+export const ApplyContainerRegistryManagerSnapshotRequest$outboundSchema:
+  z.ZodType<
+    ApplyContainerRegistryManagerSnapshotRequest$Outbound,
+    ApplyContainerRegistryManagerSnapshotRequest
+  > = z.object({
+    id: z.string(),
+    requestBody: z.lazy(() =>
+      ApplyContainerRegistryManagerSnapshotRequestBody$outboundSchema
+    ).optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      requestBody: "RequestBody",
+    });
+  });
+
+export function applyContainerRegistryManagerSnapshotRequestToJSON(
+  applyContainerRegistryManagerSnapshotRequest:
+    ApplyContainerRegistryManagerSnapshotRequest,
+): string {
+  return JSON.stringify(
+    ApplyContainerRegistryManagerSnapshotRequest$outboundSchema.parse(
+      applyContainerRegistryManagerSnapshotRequest,
+    ),
+  );
+}

package/src/models/operations/approveagentsession.ts

@@ -0,0 +1,36 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+
+export type ApproveAgentSessionRequest = {
+  id: string;
+  /**
+   * Workspace name. Required for user/session/OAuth requests. Optional for API keys because API keys are workspace-scoped; if provided with an API key, it must match the key's workspace.
+   */
+  workspace?: string | undefined;
+};
+
+/** @internal */
+export type ApproveAgentSessionRequest$Outbound = {
+  id: string;
+  workspace?: string | undefined;
+};
+
+/** @internal */
+export const ApproveAgentSessionRequest$outboundSchema: z.ZodType<
+  ApproveAgentSessionRequest$Outbound,
+  ApproveAgentSessionRequest
+> = z.object({
+  id: z.string(),
+  workspace: z.string().optional(),
+});
+
+export function approveAgentSessionRequestToJSON(
+  approveAgentSessionRequest: ApproveAgentSessionRequest,
+): string {
+  return JSON.stringify(
+    ApproveAgentSessionRequest$outboundSchema.parse(approveAgentSessionRequest),
+  );
+}

package/src/models/operations/configureprojectbuckets.ts

@@ -0,0 +1,90 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const ConfigureProjectBucketsAccess = {
+  ReadWrite: "read-write",
+} as const;
+export type ConfigureProjectBucketsAccess = ClosedEnum<
+  typeof ConfigureProjectBucketsAccess
+>;
+
+export type ConfigureProjectBucketsRequestBody = {
+  access: ConfigureProjectBucketsAccess;
+};
+
+export type ConfigureProjectBucketsRequest = {
+  /**
+   * Project ID or name.
+   */
+  idOrName: string;
+  /**
+   * Workspace name. Required for user/session/OAuth requests. Optional for API keys because API keys are workspace-scoped; if provided with an API key, it must match the key's workspace.
+   */
+  workspace?: string | undefined;
+  requestBody?: ConfigureProjectBucketsRequestBody | undefined;
+};
+
+/** @internal */
+export const ConfigureProjectBucketsAccess$outboundSchema: z.ZodEnum<
+  typeof ConfigureProjectBucketsAccess
+> = z.enum(ConfigureProjectBucketsAccess);
+
+/** @internal */
+export type ConfigureProjectBucketsRequestBody$Outbound = {
+  access: string;
+};
+
+/** @internal */
+export const ConfigureProjectBucketsRequestBody$outboundSchema: z.ZodType<
+  ConfigureProjectBucketsRequestBody$Outbound,
+  ConfigureProjectBucketsRequestBody
+> = z.object({
+  access: ConfigureProjectBucketsAccess$outboundSchema,
+});
+
+export function configureProjectBucketsRequestBodyToJSON(
+  configureProjectBucketsRequestBody: ConfigureProjectBucketsRequestBody,
+): string {
+  return JSON.stringify(
+    ConfigureProjectBucketsRequestBody$outboundSchema.parse(
+      configureProjectBucketsRequestBody,
+    ),
+  );
+}
+
+/** @internal */
+export type ConfigureProjectBucketsRequest$Outbound = {
+  idOrName: string;
+  workspace?: string | undefined;
+  RequestBody?: ConfigureProjectBucketsRequestBody$Outbound | undefined;
+};
+
+/** @internal */
+export const ConfigureProjectBucketsRequest$outboundSchema: z.ZodType<
+  ConfigureProjectBucketsRequest$Outbound,
+  ConfigureProjectBucketsRequest
+> = z.object({
+  idOrName: z.string(),
+  workspace: z.string().optional(),
+  requestBody: z.lazy(() => ConfigureProjectBucketsRequestBody$outboundSchema)
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    requestBody: "RequestBody",
+  });
+});
+
+export function configureProjectBucketsRequestToJSON(
+  configureProjectBucketsRequest: ConfigureProjectBucketsRequest,
+): string {
+  return JSON.stringify(
+    ConfigureProjectBucketsRequest$outboundSchema.parse(
+      configureProjectBucketsRequest,
+    ),
+  );
+}

package/src/models/operations/configureprojectdeployments.ts

@@ -0,0 +1,79 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+
+export type ConfigureProjectDeploymentsRequestBody = {
+  enabled: boolean;
+};
+
+export type ConfigureProjectDeploymentsRequest = {
+  /**
+   * Project ID or name.
+   */
+  idOrName: string;
+  /**
+   * Workspace name. Required for user/session/OAuth requests. Optional for API keys because API keys are workspace-scoped; if provided with an API key, it must match the key's workspace.
+   */
+  workspace?: string | undefined;
+  requestBody?: ConfigureProjectDeploymentsRequestBody | undefined;
+};
+
+/** @internal */
+export type ConfigureProjectDeploymentsRequestBody$Outbound = {
+  enabled: boolean;
+};
+
+/** @internal */
+export const ConfigureProjectDeploymentsRequestBody$outboundSchema: z.ZodType<
+  ConfigureProjectDeploymentsRequestBody$Outbound,
+  ConfigureProjectDeploymentsRequestBody
+> = z.object({
+  enabled: z.boolean(),
+});
+
+export function configureProjectDeploymentsRequestBodyToJSON(
+  configureProjectDeploymentsRequestBody:
+    ConfigureProjectDeploymentsRequestBody,
+): string {
+  return JSON.stringify(
+    ConfigureProjectDeploymentsRequestBody$outboundSchema.parse(
+      configureProjectDeploymentsRequestBody,
+    ),
+  );
+}
+
+/** @internal */
+export type ConfigureProjectDeploymentsRequest$Outbound = {
+  idOrName: string;
+  workspace?: string | undefined;
+  RequestBody?: ConfigureProjectDeploymentsRequestBody$Outbound | undefined;
+};
+
+/** @internal */
+export const ConfigureProjectDeploymentsRequest$outboundSchema: z.ZodType<
+  ConfigureProjectDeploymentsRequest$Outbound,
+  ConfigureProjectDeploymentsRequest
+> = z.object({
+  idOrName: z.string(),
+  workspace: z.string().optional(),
+  requestBody: z.lazy(() =>
+    ConfigureProjectDeploymentsRequestBody$outboundSchema
+  ).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    requestBody: "RequestBody",
+  });
+});
+
+export function configureProjectDeploymentsRequestToJSON(
+  configureProjectDeploymentsRequest: ConfigureProjectDeploymentsRequest,
+): string {
+  return JSON.stringify(
+    ConfigureProjectDeploymentsRequest$outboundSchema.parse(
+      configureProjectDeploymentsRequest,
+    ),
+  );
+}