@alienplatform/platform-api 3.3.12 → 3.3.14

package/src/models/deploymentgroup.ts

@@ -16,6 +16,10 @@ export type DeploymentGroup = {
    * Deployment group name.
    */
   name: string;
+  /**
+   * Case-sensitive, URL- and header-safe identifier from the integrating application.
+   */
+  externalId: string | null;
   /**
    * Unique identifier for the project.
    */
@@ -38,6 +42,7 @@ export const DeploymentGroup$inboundSchema: z.ZodType<
 > = z.object({
   id: z.string(),
   name: z.string(),
+  externalId: z.nullable(z.string()),
   projectId: z.string(),
   workspaceId: z.string(),
   maxDeployments: z.int().default(100),

package/src/models/deploymentgroupinfo.ts

@@ -16,6 +16,10 @@ export type DeploymentGroupInfo = {
    * Deployment group name.
    */
   name: string;
+  /**
+   * Case-sensitive, URL- and header-safe identifier from the integrating application.
+   */
+  externalId: string | null;
 };
 
 /** @internal */
@@ -25,6 +29,7 @@ export const DeploymentGroupInfo$inboundSchema: z.ZodType<
 > = z.object({
   id: z.string(),
   name: z.string(),
+  externalId: z.nullable(z.string()),
 });
 
 export function deploymentGroupInfoFromJSON(

package/src/models/deploymentinfo.ts

@@ -6,6 +6,10 @@ 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 {
+  AiAvailabilityObservation,
+  AiAvailabilityObservation$inboundSchema,
+} from "./aiavailabilityobservation.js";
 import {
   DeploymentInfoSetupConfig,
   DeploymentInfoSetupConfig$inboundSchema,
@@ -15,6 +19,10 @@ import {
   DeploymentPortalAppearance$inboundSchema,
 } from "./deploymentportalappearance.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import {
+  SetupItemStatus,
+  SetupItemStatus$inboundSchema,
+} from "./setupitemstatus.js";
 import {
   SupportedCloudRegions,
   SupportedCloudRegions$inboundSchema,
@@ -106,6 +114,10 @@ export type StackSummaryPlatform = ClosedEnum<typeof StackSummaryPlatform>;
 export type ResourceCounts = {
   workers: number;
   containers: number;
+  /**
+   * Daemon resources that run on managed runtime machines
+   */
+  daemons?: number | undefined;
   /**
    * Resources that declare managed public HTTPS endpoint setup
    */
@@ -133,6 +145,10 @@ export type StackSummary = {
    * Whether the stack contains resources that require cloud VPC networking
    */
   requiresNetwork: boolean;
+  /**
+   * Whether this release offers one remotely accessible AI resource
+   */
+  customerModels: boolean;
   resourceCounts: ResourceCounts;
   /**
    * Public endpoints declared by the active release stack
@@ -686,6 +702,23 @@ export type DeploymentInfoInstallContext = {
   targets: { [k: string]: InstallContextTargets };
 };
 
+export const ModelAvailabilitySourceStatus = {
+  Current: "current",
+  Stale: "stale",
+  Invalid: "invalid",
+} as const;
+export type ModelAvailabilitySourceStatus = ClosedEnum<
+  typeof ModelAvailabilitySourceStatus
+>;
+
+export type ModelAvailabilitySource = {
+  deploymentId: string;
+  resourceId: string;
+  observedAt: Date;
+  status: ModelAvailabilitySourceStatus;
+  availability?: AiAvailabilityObservation | undefined;
+};
+
 export const ReadinessStatus = {
   Ready: "ready",
   NotReady: "notReady",
@@ -731,6 +764,8 @@ export type DeploymentInfo = {
   packages: Packages;
   installContext: DeploymentInfoInstallContext;
   supportedRegions: SupportedCloudRegions;
+  modelAvailabilitySources: Array<ModelAvailabilitySource>;
+  setupItems?: Array<SetupItemStatus> | undefined;
   setupConfig?: DeploymentInfoSetupConfig | undefined;
   readiness?: Readiness | undefined;
 };
@@ -829,6 +864,7 @@ export const ResourceCounts$inboundSchema: z.ZodType<ResourceCounts, unknown> =
   z.object({
     workers: z.int(),
     containers: z.int(),
+    daemons: z.int().optional(),
     publicHttpsEndpoints: z.int(),
     externalInfra: z.int(),
     total: z.int(),
@@ -868,6 +904,7 @@ export const StackSummary$inboundSchema: z.ZodType<StackSummary, unknown> = z
   .object({
     platforms: z.array(StackSummaryPlatform$inboundSchema),
     requiresNetwork: z.boolean(),
+    customerModels: z.boolean(),
     resourceCounts: z.lazy(() => ResourceCounts$inboundSchema),
     publicEndpoints: z.array(z.lazy(() => PublicEndpoint$inboundSchema)),
   });
@@ -1497,6 +1534,33 @@ export function deploymentInfoInstallContextFromJSON(
   );
 }
 
+/** @internal */
+export const ModelAvailabilitySourceStatus$inboundSchema: z.ZodEnum<
+  typeof ModelAvailabilitySourceStatus
+> = z.enum(ModelAvailabilitySourceStatus);
+
+/** @internal */
+export const ModelAvailabilitySource$inboundSchema: z.ZodType<
+  ModelAvailabilitySource,
+  unknown
+> = z.object({
+  deploymentId: z.string(),
+  resourceId: z.string(),
+  observedAt: z.iso.datetime({ offset: true }).transform(v => new Date(v)),
+  status: ModelAvailabilitySourceStatus$inboundSchema,
+  availability: AiAvailabilityObservation$inboundSchema.optional(),
+});
+
+export function modelAvailabilitySourceFromJSON(
+  jsonString: string,
+): SafeParseResult<ModelAvailabilitySource, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ModelAvailabilitySource$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ModelAvailabilitySource' from JSON`,
+  );
+}
+
 /** @internal */
 export const ReadinessStatus$inboundSchema: z.ZodEnum<typeof ReadinessStatus> =
   z.enum(ReadinessStatus);
@@ -1552,6 +1616,10 @@ export const DeploymentInfo$inboundSchema: z.ZodType<DeploymentInfo, unknown> =
     packages: z.lazy(() => Packages$inboundSchema),
     installContext: z.lazy(() => DeploymentInfoInstallContext$inboundSchema),
     supportedRegions: SupportedCloudRegions$inboundSchema,
+    modelAvailabilitySources: z.array(
+      z.lazy(() => ModelAvailabilitySource$inboundSchema),
+    ),
+    setupItems: z.array(SetupItemStatus$inboundSchema).optional(),
     setupConfig: DeploymentInfoSetupConfig$inboundSchema.optional(),
     readiness: z.lazy(() => Readiness$inboundSchema).optional(),
   });

package/src/models/deploymentinfosetupconfig.ts

@@ -35,6 +35,96 @@ export type DeploymentInfoSetupConfigEnvironmentVariable = {
   targetResources: Array<string> | null;
 };
 
+export const DeploymentInfoSetupConfigItemEnum = {
+  Deployment: "deployment",
+  Models: "models",
+  Keys: "keys",
+  Bucket: "bucket",
+  Registry: "registry",
+} as const;
+export type DeploymentInfoSetupConfigItemEnum = ClosedEnum<
+  typeof DeploymentInfoSetupConfigItemEnum
+>;
+
+export const DeploymentInfoSetupConfigDefinitionId = {
+  CustomerAi: "customer-ai",
+  CustomerKey: "customer-key",
+  CustomerStorage: "customer-storage",
+  CustomerRegistry: "customer-registry",
+} as const;
+export type DeploymentInfoSetupConfigDefinitionId = ClosedEnum<
+  typeof DeploymentInfoSetupConfigDefinitionId
+>;
+
+export type DeploymentInfoSetupConfigSourceBuiltIn = {
+  type: "built-in";
+  definitionId: DeploymentInfoSetupConfigDefinitionId;
+  version: string;
+  /**
+   * Unique identifier for the release.
+   */
+  sourceReleaseId: string;
+};
+
+export type DeploymentInfoSetupConfigSourceProjectRelease = {
+  type: "project-release";
+  releaseChannel: string;
+  /**
+   * Unique identifier for the release.
+   */
+  releaseId: string;
+  resourceId?: string | undefined;
+};
+
+export type DeploymentInfoSetupConfigSourceUnion =
+  | DeploymentInfoSetupConfigSourceProjectRelease
+  | DeploymentInfoSetupConfigSourceBuiltIn;
+
+export const DeploymentInfoSetupConfigAllowedProvider = {
+  AwsBedrock: "aws-bedrock",
+  GcpVertex: "gcp-vertex",
+  AzureFoundry: "azure-foundry",
+  Anthropic: "anthropic",
+  Databricks: "databricks",
+  Openai: "openai",
+} as const;
+export type DeploymentInfoSetupConfigAllowedProvider = ClosedEnum<
+  typeof DeploymentInfoSetupConfigAllowedProvider
+>;
+
+export const DeploymentInfoSetupConfigClientApi = {
+  OpenaiChat: "openai-chat",
+  OpenaiResponses: "openai-responses",
+  AnthropicMessages: "anthropic-messages",
+} as const;
+export type DeploymentInfoSetupConfigClientApi = ClosedEnum<
+  typeof DeploymentInfoSetupConfigClientApi
+>;
+
+export type DeploymentInfoSetupConfigModelRequirement = {
+  publicModelId: string;
+  clientApis: Array<DeploymentInfoSetupConfigClientApi>;
+  required: boolean;
+};
+
+export type DeploymentInfoSetupConfigConfiguration = {
+  allowedProviders?:
+    | Array<DeploymentInfoSetupConfigAllowedProvider>
+    | undefined;
+  modelRequirements?:
+    | Array<DeploymentInfoSetupConfigModelRequirement>
+    | undefined;
+};
+
+export type DeploymentInfoSetupConfigItem = {
+  item: DeploymentInfoSetupConfigItemEnum;
+  source:
+    | DeploymentInfoSetupConfigSourceProjectRelease
+    | DeploymentInfoSetupConfigSourceBuiltIn;
+  required: boolean;
+  configuration?: DeploymentInfoSetupConfigConfiguration | undefined;
+};
+
 export const DeploymentInfoSetupConfigTypeStringList = {
   StringList: "stringList",
 } as const;
@@ -288,6 +378,7 @@ export type DeploymentInfoSetupConfig = {
   metadata: { [k: string]: any | null };
   policy: DeploymentSetupPolicy;
   environmentVariables: Array<DeploymentInfoSetupConfigEnvironmentVariable>;
+  items?: Array<DeploymentInfoSetupConfigItem> | undefined;
   inputs?: Array<DeploymentInfoSetupConfigInput> | undefined;
   inputValues?: Array<ResolvedStackInputSummary> | undefined;
 };
@@ -316,6 +407,169 @@ export function deploymentInfoSetupConfigEnvironmentVariableFromJSON(
   );
 }
 
+/** @internal */
+export const DeploymentInfoSetupConfigItemEnum$inboundSchema: z.ZodEnum<
+  typeof DeploymentInfoSetupConfigItemEnum
+> = z.enum(DeploymentInfoSetupConfigItemEnum);
+
+/** @internal */
+export const DeploymentInfoSetupConfigDefinitionId$inboundSchema: z.ZodEnum<
+  typeof DeploymentInfoSetupConfigDefinitionId
+> = z.enum(DeploymentInfoSetupConfigDefinitionId);
+
+/** @internal */
+export const DeploymentInfoSetupConfigSourceBuiltIn$inboundSchema: z.ZodType<
+  DeploymentInfoSetupConfigSourceBuiltIn,
+  unknown
+> = z.object({
+  type: z.literal("built-in"),
+  definitionId: DeploymentInfoSetupConfigDefinitionId$inboundSchema,
+  version: z.string(),
+  sourceReleaseId: z.string(),
+});
+
+export function deploymentInfoSetupConfigSourceBuiltInFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoSetupConfigSourceBuiltIn, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DeploymentInfoSetupConfigSourceBuiltIn$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoSetupConfigSourceBuiltIn' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoSetupConfigSourceProjectRelease$inboundSchema:
+  z.ZodType<DeploymentInfoSetupConfigSourceProjectRelease, unknown> = z.object({
+    type: z.literal("project-release"),
+    releaseChannel: z.string(),
+    releaseId: z.string(),
+    resourceId: z.string().optional(),
+  });
+
+export function deploymentInfoSetupConfigSourceProjectReleaseFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  DeploymentInfoSetupConfigSourceProjectRelease,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DeploymentInfoSetupConfigSourceProjectRelease$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'DeploymentInfoSetupConfigSourceProjectRelease' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoSetupConfigSourceUnion$inboundSchema: z.ZodType<
+  DeploymentInfoSetupConfigSourceUnion,
+  unknown
+> = z.union([
+  z.lazy(() => DeploymentInfoSetupConfigSourceProjectRelease$inboundSchema),
+  z.lazy(() => DeploymentInfoSetupConfigSourceBuiltIn$inboundSchema),
+]);
+
+export function deploymentInfoSetupConfigSourceUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoSetupConfigSourceUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DeploymentInfoSetupConfigSourceUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoSetupConfigSourceUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoSetupConfigAllowedProvider$inboundSchema: z.ZodEnum<
+  typeof DeploymentInfoSetupConfigAllowedProvider
+> = z.enum(DeploymentInfoSetupConfigAllowedProvider);
+
+/** @internal */
+export const DeploymentInfoSetupConfigClientApi$inboundSchema: z.ZodEnum<
+  typeof DeploymentInfoSetupConfigClientApi
+> = z.enum(DeploymentInfoSetupConfigClientApi);
+
+/** @internal */
+export const DeploymentInfoSetupConfigModelRequirement$inboundSchema: z.ZodType<
+  DeploymentInfoSetupConfigModelRequirement,
+  unknown
+> = z.object({
+  publicModelId: z.string(),
+  clientApis: z.array(DeploymentInfoSetupConfigClientApi$inboundSchema),
+  required: z.boolean(),
+});
+
+export function deploymentInfoSetupConfigModelRequirementFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  DeploymentInfoSetupConfigModelRequirement,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DeploymentInfoSetupConfigModelRequirement$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'DeploymentInfoSetupConfigModelRequirement' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoSetupConfigConfiguration$inboundSchema: z.ZodType<
+  DeploymentInfoSetupConfigConfiguration,
+  unknown
+> = z.object({
+  allowedProviders: z.array(
+    DeploymentInfoSetupConfigAllowedProvider$inboundSchema,
+  ).optional(),
+  modelRequirements: z.array(
+    z.lazy(() => DeploymentInfoSetupConfigModelRequirement$inboundSchema),
+  ).optional(),
+});
+
+export function deploymentInfoSetupConfigConfigurationFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoSetupConfigConfiguration, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DeploymentInfoSetupConfigConfiguration$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoSetupConfigConfiguration' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoSetupConfigItem$inboundSchema: z.ZodType<
+  DeploymentInfoSetupConfigItem,
+  unknown
+> = z.object({
+  item: DeploymentInfoSetupConfigItemEnum$inboundSchema,
+  source: z.union([
+    z.lazy(() => DeploymentInfoSetupConfigSourceProjectRelease$inboundSchema),
+    z.lazy(() => DeploymentInfoSetupConfigSourceBuiltIn$inboundSchema),
+  ]),
+  required: z.boolean(),
+  configuration: z.lazy(() =>
+    DeploymentInfoSetupConfigConfiguration$inboundSchema
+  ).optional(),
+});
+
+export function deploymentInfoSetupConfigItemFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoSetupConfigItem, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoSetupConfigItem$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoSetupConfigItem' from JSON`,
+  );
+}
+
 /** @internal */
 export const DeploymentInfoSetupConfigTypeStringList$inboundSchema: z.ZodEnum<
   typeof DeploymentInfoSetupConfigTypeStringList
@@ -612,6 +866,8 @@ export const DeploymentInfoSetupConfig$inboundSchema: z.ZodType<
   environmentVariables: z.array(
     z.lazy(() => DeploymentInfoSetupConfigEnvironmentVariable$inboundSchema),
   ),
+  items: z.array(z.lazy(() => DeploymentInfoSetupConfigItem$inboundSchema))
+    .optional(),
   inputs: z.array(z.lazy(() => DeploymentInfoSetupConfigInput$inboundSchema))
     .optional(),
   inputValues: z.array(ResolvedStackInputSummary$inboundSchema).optional(),

package/src/models/deploymentlinksetupresponse.ts

@@ -11,10 +11,16 @@ import {
   DeploymentSetupMethod$inboundSchema,
 } from "./deploymentsetupmethod.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import {
-  StackByPlatform,
-  StackByPlatform$inboundSchema,
-} from "./stackbyplatform.js";
+
+export type DeploymentLinkSetupResponseStack = {
+  aws?: any | null | undefined;
+  gcp?: any | null | undefined;
+  azure?: any | null | undefined;
+  kubernetes?: any | null | undefined;
+  machines?: any | null | undefined;
+  local?: any | null | undefined;
+  test?: any | null | undefined;
+};
 
 export type ActiveRelease = {
   /**
@@ -22,9 +28,39 @@ export type ActiveRelease = {
    */
   id: string;
   version: string | null;
-  stack: StackByPlatform | null;
+  stack: DeploymentLinkSetupResponseStack | null;
 };
 
+/**
+ * Represents the target cloud platform.
+ */
+export const DeploymentLinkSetupResponseSupportedPlatform = {
+  Aws: "aws",
+  Gcp: "gcp",
+  Azure: "azure",
+  Kubernetes: "kubernetes",
+  Machines: "machines",
+  Local: "local",
+  Test: "test",
+} as const;
+/**
+ * Represents the target cloud platform.
+ */
+export type DeploymentLinkSetupResponseSupportedPlatform = ClosedEnum<
+  typeof DeploymentLinkSetupResponseSupportedPlatform
+>;
+
+export const DeploymentLinkSetupResponseSetupItem = {
+  Deployment: "deployment",
+  Models: "models",
+  Keys: "keys",
+  Bucket: "bucket",
+  Registry: "registry",
+} as const;
+export type DeploymentLinkSetupResponseSetupItem = ClosedEnum<
+  typeof DeploymentLinkSetupResponseSetupItem
+>;
+
 /**
  * Types of packages that can be built
  */
@@ -40,18 +76,63 @@ export const VisiblePackageType = {
  */
 export type VisiblePackageType = ClosedEnum<typeof VisiblePackageType>;
 
+/**
+ * Whether at least one complete automated setup package is ready across all selected setup items.
+ */
+export const SetupPackagesStatus = {
+  Preparing: "preparing",
+  Ready: "ready",
+  Failed: "failed",
+} as const;
+/**
+ * Whether at least one complete automated setup package is ready across all selected setup items.
+ */
+export type SetupPackagesStatus = ClosedEnum<typeof SetupPackagesStatus>;
+
 export type DeploymentLinkSetupResponse = {
-  activeRelease: ActiveRelease;
+  activeRelease: ActiveRelease | null;
+  supportedPlatforms: Array<DeploymentLinkSetupResponseSupportedPlatform>;
+  setupItems: Array<DeploymentLinkSetupResponseSetupItem>;
   visiblePackageTypes: Array<VisiblePackageType>;
   visibleSetupMethods: Array<DeploymentSetupMethod>;
+  /**
+   * Whether at least one complete automated setup package is ready across all selected setup items.
+   */
+  setupPackagesStatus: SetupPackagesStatus;
 };
 
+/** @internal */
+export const DeploymentLinkSetupResponseStack$inboundSchema: z.ZodType<
+  DeploymentLinkSetupResponseStack,
+  unknown
+> = z.object({
+  aws: z.nullable(z.any()).optional(),
+  gcp: z.nullable(z.any()).optional(),
+  azure: z.nullable(z.any()).optional(),
+  kubernetes: z.nullable(z.any()).optional(),
+  machines: z.nullable(z.any()).optional(),
+  local: z.nullable(z.any()).optional(),
+  test: z.nullable(z.any()).optional(),
+});
+
+export function deploymentLinkSetupResponseStackFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentLinkSetupResponseStack, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentLinkSetupResponseStack$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentLinkSetupResponseStack' from JSON`,
+  );
+}
+
 /** @internal */
 export const ActiveRelease$inboundSchema: z.ZodType<ActiveRelease, unknown> = z
   .object({
     id: z.string(),
     version: z.nullable(z.string()),
-    stack: z.nullable(StackByPlatform$inboundSchema),
+    stack: z.nullable(
+      z.lazy(() => DeploymentLinkSetupResponseStack$inboundSchema),
+    ),
   });
 
 export function activeReleaseFromJSON(
@@ -64,19 +145,40 @@ export function activeReleaseFromJSON(
   );
 }
 
+/** @internal */
+export const DeploymentLinkSetupResponseSupportedPlatform$inboundSchema:
+  z.ZodEnum<typeof DeploymentLinkSetupResponseSupportedPlatform> = z.enum(
+    DeploymentLinkSetupResponseSupportedPlatform,
+  );
+
+/** @internal */
+export const DeploymentLinkSetupResponseSetupItem$inboundSchema: z.ZodEnum<
+  typeof DeploymentLinkSetupResponseSetupItem
+> = z.enum(DeploymentLinkSetupResponseSetupItem);
+
 /** @internal */
 export const VisiblePackageType$inboundSchema: z.ZodEnum<
   typeof VisiblePackageType
 > = z.enum(VisiblePackageType);
 
+/** @internal */
+export const SetupPackagesStatus$inboundSchema: z.ZodEnum<
+  typeof SetupPackagesStatus
+> = z.enum(SetupPackagesStatus);
+
 /** @internal */
 export const DeploymentLinkSetupResponse$inboundSchema: z.ZodType<
   DeploymentLinkSetupResponse,
   unknown
 > = z.object({
-  activeRelease: z.lazy(() => ActiveRelease$inboundSchema),
+  activeRelease: z.nullable(z.lazy(() => ActiveRelease$inboundSchema)),
+  supportedPlatforms: z.array(
+    DeploymentLinkSetupResponseSupportedPlatform$inboundSchema,
+  ),
+  setupItems: z.array(DeploymentLinkSetupResponseSetupItem$inboundSchema),
   visiblePackageTypes: z.array(VisiblePackageType$inboundSchema),
   visibleSetupMethods: z.array(DeploymentSetupMethod$inboundSchema),
+  setupPackagesStatus: SetupPackagesStatus$inboundSchema,
 });
 
 export function deploymentLinkSetupResponseFromJSON(

package/src/models/deploymentlistitemresponse.ts

@@ -14,6 +14,10 @@ import {
   DeploymentProjectInfo,
   DeploymentProjectInfo$inboundSchema,
 } from "./deploymentprojectinfo.js";
+import {
+  DeploymentPurpose,
+  DeploymentPurpose$inboundSchema,
+} from "./deploymentpurpose.js";
 import {
   DeploymentReleaseInfo,
   DeploymentReleaseInfo$inboundSchema,
@@ -358,6 +362,10 @@ export type DeploymentListItemResponse = {
    * ID of deployment group this deployment belongs to
    */
   deploymentGroupId: string;
+  /**
+   * Operational purpose of this deployment within its customer environment.
+   */
+  purpose: DeploymentPurpose;
   /**
    * Cloud environment information
    */
@@ -382,6 +390,7 @@ export type DeploymentListItemResponse = {
    * ID of the pinned release
    */
   pinnedReleaseId?: string | null | undefined;
+  releaseChannel: string;
   /**
    * Setup source that imported this deployment
    */
@@ -684,6 +693,7 @@ export const DeploymentListItemResponse$inboundSchema: z.ZodType<
   platform: DeploymentListItemResponsePlatform$inboundSchema,
   deploymentProtocolVersion: z.int(),
   deploymentGroupId: z.string(),
+  purpose: DeploymentPurpose$inboundSchema,
   environmentInfo: z.nullable(
     z.union([
       z.lazy(() => DeploymentListItemResponseEnvironmentInfoGcp$inboundSchema),
@@ -703,6 +713,7 @@ export const DeploymentListItemResponse$inboundSchema: z.ZodType<
   currentReleaseId: z.nullable(z.string()).optional(),
   desiredReleaseId: z.nullable(z.string()).optional(),
   pinnedReleaseId: z.nullable(z.string()).optional(),
+  releaseChannel: z.string(),
   importSource: z.nullable(DeploymentListItemResponseImportSource$inboundSchema)
     .optional(),
   setupMethod: z.nullable(DeploymentListItemResponseSetupMethod$inboundSchema)

package/src/models/deploymentpurpose.ts

@@ -0,0 +1,30 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+
+/**
+ * Filter by deployment purpose
+ */
+export const DeploymentPurpose = {
+  Application: "application",
+  Encryption: "encryption",
+  Ai: "ai",
+  Storage: "storage",
+  ContainerRegistry: "container-registry",
+} as const;
+/**
+ * Filter by deployment purpose
+ */
+export type DeploymentPurpose = ClosedEnum<typeof DeploymentPurpose>;
+
+/** @internal */
+export const DeploymentPurpose$inboundSchema: z.ZodEnum<
+  typeof DeploymentPurpose
+> = z.enum(DeploymentPurpose);
+/** @internal */
+export const DeploymentPurpose$outboundSchema: z.ZodEnum<
+  typeof DeploymentPurpose
+> = DeploymentPurpose$inboundSchema;