@alienplatform/platform-api 1.8.0 → 1.9.0

package/src/models/createsetupregistrationoperationrequest.ts

@@ -27,6 +27,11 @@ import {
   SetupRegistrationCloudFormationTarget$Outbound,
   SetupRegistrationCloudFormationTarget$outboundSchema,
 } from "./setupregistrationcloudformationtarget.js";
+import {
+  StackInputValueRequest,
+  StackInputValueRequest$Outbound,
+  StackInputValueRequest$outboundSchema,
+} from "./stackinputvaluerequest.js";
 
 /**
  * Cloud platform of the imported stack
@@ -46,6 +51,65 @@ export type CreateSetupRegistrationOperationRequestPlatform = ClosedEnum<
   typeof CreateSetupRegistrationOperationRequestPlatform
 >;
 
+export type CreateSetupRegistrationOperationRequestPoolsAutoscale = {
+  /**
+   * Provider machine type selected for this deployment.
+   */
+  machine?: string | null | undefined;
+  /**
+   * Maximum machine count.
+   */
+  max: number;
+  /**
+   * Minimum machine count.
+   */
+  min: number;
+  mode: "autoscale";
+};
+
+export type CreateSetupRegistrationOperationRequestPoolsFixed = {
+  /**
+   * Provider machine type selected for this deployment.
+   */
+  machine?: string | null | undefined;
+  /**
+   * Number of machines to run.
+   */
+  machines: number;
+  mode: "fixed";
+};
+
+/**
+ * User-selected deployment settings for one compute pool.
+ */
+export type CreateSetupRegistrationOperationRequestPoolsUnion =
+  | CreateSetupRegistrationOperationRequestPoolsFixed
+  | CreateSetupRegistrationOperationRequestPoolsAutoscale;
+
+/**
+ * Deployment-time compute choices for Alien-managed compute pools.
+ *
+ * @remarks
+ *
+ * Application source declares portable pool requirements. This settings
+ * object stores the concrete choices made for one deployment, such as the
+ * provider machine type and selected machine counts.
+ */
+export type CreateSetupRegistrationOperationRequestCompute = {
+  /**
+   * Selected compute choices keyed by pool ID.
+   */
+  pools?: {
+    [k: string]:
+      | CreateSetupRegistrationOperationRequestPoolsFixed
+      | CreateSetupRegistrationOperationRequestPoolsAutoscale;
+  } | undefined;
+};
+
+export type CreateSetupRegistrationOperationRequestComputeUnion =
+  | CreateSetupRegistrationOperationRequestCompute
+  | any;
+
 /**
  * Deployment model: how updates are delivered to the remote environment.
  */
@@ -1060,6 +1124,11 @@ export type CreateSetupRegistrationOperationRequestUpdates = ClosedEnum<
  * is platform-derived (from the Manager's ServiceAccount).
  */
 export type CreateSetupRegistrationOperationRequestStackSettings = {
+  compute?:
+    | CreateSetupRegistrationOperationRequestCompute
+    | any
+    | null
+    | undefined;
   /**
    * Deployment model: how updates are delivered to the remote environment.
    */
@@ -1272,6 +1341,7 @@ export type CreateSetupRegistrationOperationRequest = {
   action: SetupRegistrationAction;
   sourceKind: ImportSourceKind;
   source?: CreateSetupRegistrationOperationRequestSource | null | undefined;
+  inputValues?: { [k: string]: StackInputValueRequest } | undefined;
   /**
    * Unique identifier for the deployment.
    */
@@ -1286,6 +1356,161 @@ export const CreateSetupRegistrationOperationRequestPlatform$outboundSchema:
     CreateSetupRegistrationOperationRequestPlatform,
   );
 
+/** @internal */
+export type CreateSetupRegistrationOperationRequestPoolsAutoscale$Outbound = {
+  machine?: string | null | undefined;
+  max: number;
+  min: number;
+  mode: "autoscale";
+};
+
+/** @internal */
+export const CreateSetupRegistrationOperationRequestPoolsAutoscale$outboundSchema:
+  z.ZodType<
+    CreateSetupRegistrationOperationRequestPoolsAutoscale$Outbound,
+    CreateSetupRegistrationOperationRequestPoolsAutoscale
+  > = z.object({
+    machine: z.nullable(z.string()).optional(),
+    max: z.int(),
+    min: z.int(),
+    mode: z.literal("autoscale"),
+  });
+
+export function createSetupRegistrationOperationRequestPoolsAutoscaleToJSON(
+  createSetupRegistrationOperationRequestPoolsAutoscale:
+    CreateSetupRegistrationOperationRequestPoolsAutoscale,
+): string {
+  return JSON.stringify(
+    CreateSetupRegistrationOperationRequestPoolsAutoscale$outboundSchema.parse(
+      createSetupRegistrationOperationRequestPoolsAutoscale,
+    ),
+  );
+}
+
+/** @internal */
+export type CreateSetupRegistrationOperationRequestPoolsFixed$Outbound = {
+  machine?: string | null | undefined;
+  machines: number;
+  mode: "fixed";
+};
+
+/** @internal */
+export const CreateSetupRegistrationOperationRequestPoolsFixed$outboundSchema:
+  z.ZodType<
+    CreateSetupRegistrationOperationRequestPoolsFixed$Outbound,
+    CreateSetupRegistrationOperationRequestPoolsFixed
+  > = z.object({
+    machine: z.nullable(z.string()).optional(),
+    machines: z.int(),
+    mode: z.literal("fixed"),
+  });
+
+export function createSetupRegistrationOperationRequestPoolsFixedToJSON(
+  createSetupRegistrationOperationRequestPoolsFixed:
+    CreateSetupRegistrationOperationRequestPoolsFixed,
+): string {
+  return JSON.stringify(
+    CreateSetupRegistrationOperationRequestPoolsFixed$outboundSchema.parse(
+      createSetupRegistrationOperationRequestPoolsFixed,
+    ),
+  );
+}
+
+/** @internal */
+export type CreateSetupRegistrationOperationRequestPoolsUnion$Outbound =
+  | CreateSetupRegistrationOperationRequestPoolsFixed$Outbound
+  | CreateSetupRegistrationOperationRequestPoolsAutoscale$Outbound;
+
+/** @internal */
+export const CreateSetupRegistrationOperationRequestPoolsUnion$outboundSchema:
+  z.ZodType<
+    CreateSetupRegistrationOperationRequestPoolsUnion$Outbound,
+    CreateSetupRegistrationOperationRequestPoolsUnion
+  > = z.union([
+    z.lazy(() =>
+      CreateSetupRegistrationOperationRequestPoolsFixed$outboundSchema
+    ),
+    z.lazy(() =>
+      CreateSetupRegistrationOperationRequestPoolsAutoscale$outboundSchema
+    ),
+  ]);
+
+export function createSetupRegistrationOperationRequestPoolsUnionToJSON(
+  createSetupRegistrationOperationRequestPoolsUnion:
+    CreateSetupRegistrationOperationRequestPoolsUnion,
+): string {
+  return JSON.stringify(
+    CreateSetupRegistrationOperationRequestPoolsUnion$outboundSchema.parse(
+      createSetupRegistrationOperationRequestPoolsUnion,
+    ),
+  );
+}
+
+/** @internal */
+export type CreateSetupRegistrationOperationRequestCompute$Outbound = {
+  pools?: {
+    [k: string]:
+      | CreateSetupRegistrationOperationRequestPoolsFixed$Outbound
+      | CreateSetupRegistrationOperationRequestPoolsAutoscale$Outbound;
+  } | undefined;
+};
+
+/** @internal */
+export const CreateSetupRegistrationOperationRequestCompute$outboundSchema:
+  z.ZodType<
+    CreateSetupRegistrationOperationRequestCompute$Outbound,
+    CreateSetupRegistrationOperationRequestCompute
+  > = z.object({
+    pools: z.record(
+      z.string(),
+      z.union([
+        z.lazy(() =>
+          CreateSetupRegistrationOperationRequestPoolsFixed$outboundSchema
+        ),
+        z.lazy(() =>
+          CreateSetupRegistrationOperationRequestPoolsAutoscale$outboundSchema
+        ),
+      ]),
+    ).optional(),
+  });
+
+export function createSetupRegistrationOperationRequestComputeToJSON(
+  createSetupRegistrationOperationRequestCompute:
+    CreateSetupRegistrationOperationRequestCompute,
+): string {
+  return JSON.stringify(
+    CreateSetupRegistrationOperationRequestCompute$outboundSchema.parse(
+      createSetupRegistrationOperationRequestCompute,
+    ),
+  );
+}
+
+/** @internal */
+export type CreateSetupRegistrationOperationRequestComputeUnion$Outbound =
+  | CreateSetupRegistrationOperationRequestCompute$Outbound
+  | any;
+
+/** @internal */
+export const CreateSetupRegistrationOperationRequestComputeUnion$outboundSchema:
+  z.ZodType<
+    CreateSetupRegistrationOperationRequestComputeUnion$Outbound,
+    CreateSetupRegistrationOperationRequestComputeUnion
+  > = z.union([
+    z.lazy(() => CreateSetupRegistrationOperationRequestCompute$outboundSchema),
+    z.any(),
+  ]);
+
+export function createSetupRegistrationOperationRequestComputeUnionToJSON(
+  createSetupRegistrationOperationRequestComputeUnion:
+    CreateSetupRegistrationOperationRequestComputeUnion,
+): string {
+  return JSON.stringify(
+    CreateSetupRegistrationOperationRequestComputeUnion$outboundSchema.parse(
+      createSetupRegistrationOperationRequestComputeUnion,
+    ),
+  );
+}
+
 /** @internal */
 export const CreateSetupRegistrationOperationRequestDeploymentModel$outboundSchema:
   z.ZodEnum<typeof CreateSetupRegistrationOperationRequestDeploymentModel> = z
@@ -3638,6 +3863,11 @@ export const CreateSetupRegistrationOperationRequestUpdates$outboundSchema:
 
 /** @internal */
 export type CreateSetupRegistrationOperationRequestStackSettings$Outbound = {
+  compute?:
+    | CreateSetupRegistrationOperationRequestCompute$Outbound
+    | any
+    | null
+    | undefined;
   deploymentModel?: string | undefined;
   domains?:
     | CreateSetupRegistrationOperationRequestDomains$Outbound
@@ -3673,6 +3903,14 @@ export const CreateSetupRegistrationOperationRequestStackSettings$outboundSchema
     CreateSetupRegistrationOperationRequestStackSettings$Outbound,
     CreateSetupRegistrationOperationRequestStackSettings
   > = z.object({
+    compute: z.nullable(
+      z.union([
+        z.lazy(() =>
+          CreateSetupRegistrationOperationRequestCompute$outboundSchema
+        ),
+        z.any(),
+      ]),
+    ).optional(),
     deploymentModel:
       CreateSetupRegistrationOperationRequestDeploymentModel$outboundSchema
         .optional(),
@@ -3995,6 +4233,7 @@ export type CreateSetupRegistrationOperationRequest$Outbound = {
     | CreateSetupRegistrationOperationRequestSource$Outbound
     | null
     | undefined;
+  inputValues?: { [k: string]: StackInputValueRequest$Outbound } | undefined;
   deploymentId?: string | null | undefined;
   idempotencyKey?: string | undefined;
   cloudFormation?:
@@ -4013,6 +4252,8 @@ export const CreateSetupRegistrationOperationRequest$outboundSchema: z.ZodType<
   source: z.nullable(
     z.lazy(() => CreateSetupRegistrationOperationRequestSource$outboundSchema),
   ).optional(),
+  inputValues: z.record(z.string(), StackInputValueRequest$outboundSchema)
+    .optional(),
   deploymentId: z.nullable(z.string()).optional(),
   idempotencyKey: z.string().optional(),
   cloudFormation: z.nullable(

package/src/models/debugpackagepresignedurls.ts

@@ -0,0 +1,32 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export type DebugPackagePresignedURLs = {
+  readUrl: string;
+  writeUrl: string;
+};
+
+/** @internal */
+export const DebugPackagePresignedURLs$inboundSchema: z.ZodType<
+  DebugPackagePresignedURLs,
+  unknown
+> = z.object({
+  readUrl: z.string(),
+  writeUrl: z.string(),
+});
+
+export function debugPackagePresignedURLsFromJSON(
+  jsonString: string,
+): SafeParseResult<DebugPackagePresignedURLs, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DebugPackagePresignedURLs$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DebugPackagePresignedURLs' from JSON`,
+  );
+}

package/src/models/debugsession.ts

@@ -0,0 +1,118 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import {
+  DebugPackagePresignedURLs,
+  DebugPackagePresignedURLs$inboundSchema,
+} from "./debugpackagepresignedurls.js";
+import {
+  DebugSessionState,
+  DebugSessionState$inboundSchema,
+} from "./debugsessionstate.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+/**
+ * Deployment model: how updates are delivered to the remote environment.
+ */
+export const DebugSessionMode = {
+  Push: "push",
+  Pull: "pull",
+} as const;
+/**
+ * Deployment model: how updates are delivered to the remote environment.
+ */
+export type DebugSessionMode = ClosedEnum<typeof DebugSessionMode>;
+
+/**
+ * Represents the target cloud platform.
+ */
+export const DebugSessionProvider = {
+  Aws: "aws",
+  Gcp: "gcp",
+  Azure: "azure",
+  Kubernetes: "kubernetes",
+  Local: "local",
+  Test: "test",
+} as const;
+/**
+ * Represents the target cloud platform.
+ */
+export type DebugSessionProvider = ClosedEnum<typeof DebugSessionProvider>;
+
+export type DebugSession = {
+  /**
+   * Unique identifier for the debug session.
+   */
+  id: string;
+  owner?: string | null | undefined;
+  state: DebugSessionState;
+  /**
+   * Deployment model: how updates are delivered to the remote environment.
+   */
+  mode: DebugSessionMode;
+  /**
+   * Represents the target cloud platform.
+   */
+  provider?: DebugSessionProvider | null | undefined;
+  presignedUrls: { [k: string]: DebugPackagePresignedURLs };
+  error?: any | null | undefined;
+  createdAt: Date;
+  expiresAt: Date;
+  /**
+   * Unique identifier for the deployment.
+   */
+  deploymentId: string;
+  /**
+   * Unique identifier for the project.
+   */
+  projectId: string;
+  /**
+   * Unique identifier for the workspace.
+   */
+  workspaceId: string;
+};
+
+/** @internal */
+export const DebugSessionMode$inboundSchema: z.ZodEnum<
+  typeof DebugSessionMode
+> = z.enum(DebugSessionMode);
+
+/** @internal */
+export const DebugSessionProvider$inboundSchema: z.ZodEnum<
+  typeof DebugSessionProvider
+> = z.enum(DebugSessionProvider);
+
+/** @internal */
+export const DebugSession$inboundSchema: z.ZodType<DebugSession, unknown> = z
+  .object({
+    id: z.string(),
+    owner: z.nullable(z.string()).optional(),
+    state: DebugSessionState$inboundSchema,
+    mode: DebugSessionMode$inboundSchema,
+    provider: z.nullable(DebugSessionProvider$inboundSchema).optional(),
+    presignedUrls: z.record(
+      z.string(),
+      DebugPackagePresignedURLs$inboundSchema,
+    ),
+    error: z.nullable(z.any()).optional(),
+    createdAt: z.iso.datetime({ offset: true }).transform(v => new Date(v)),
+    expiresAt: z.iso.datetime({ offset: true }).transform(v => new Date(v)),
+    deploymentId: z.string(),
+    projectId: z.string(),
+    workspaceId: z.string(),
+  });
+
+export function debugSessionFromJSON(
+  jsonString: string,
+): SafeParseResult<DebugSession, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DebugSession$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DebugSession' from JSON`,
+  );
+}

package/src/models/debugsessionlistresponse.ts

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { DebugSession, DebugSession$inboundSchema } from "./debugsession.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+/**
+ * Paginated response
+ */
+export type DebugSessionListResponse = {
+  /**
+   * Items in this page
+   */
+  items: Array<DebugSession>;
+  /**
+   * Cursor for the next page, null if last page
+   */
+  nextCursor: string | null;
+};
+
+/** @internal */
+export const DebugSessionListResponse$inboundSchema: z.ZodType<
+  DebugSessionListResponse,
+  unknown
+> = z.object({
+  items: z.array(DebugSession$inboundSchema),
+  nextCursor: z.nullable(z.string()),
+});
+
+export function debugSessionListResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DebugSessionListResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DebugSessionListResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DebugSessionListResponse' from JSON`,
+  );
+}

package/src/models/debugsessionstate.ts

@@ -0,0 +1,31 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+
+/**
+ * Filter by session state
+ */
+export const DebugSessionState = {
+  Pending: "pending",
+  Running: "running",
+  Stopping: "stopping",
+  Stopped: "stopped",
+  Expired: "expired",
+  Failed: "failed",
+} as const;
+/**
+ * Filter by session state
+ */
+export type DebugSessionState = ClosedEnum<typeof DebugSessionState>;
+
+/** @internal */
+export const DebugSessionState$inboundSchema: z.ZodEnum<
+  typeof DebugSessionState
+> = z.enum(DebugSessionState);
+/** @internal */
+export const DebugSessionState$outboundSchema: z.ZodEnum<
+  typeof DebugSessionState
+> = DebugSessionState$inboundSchema;