@alienplatform/manager-api 1.14.0 → 1.15.0-dev.e74fae6cd01b61e77a285276f264b5480977f41a

package/src/models/containerheartbeatdata.ts

@@ -101,7 +101,9 @@ export type ContainerHeartbeatDataHorizonPlatform = {
   cpu?: MetricSample | null | undefined;
   events: Array<ManagedRuntimeEventSnapshot>;
   image?: string | null | undefined;
+  latestUpdateTimestamp?: string | null | undefined;
   memory?: MetricSample | null | undefined;
+  observedImage?: string | null | undefined;
   replicaUnits: Array<ManagedRuntimeUnitStatus>;
   replicas: WorkloadReplicaStatus;
   schedulingMode: HorizonWorkloadSchedulingMode;
@@ -217,7 +219,9 @@ export type ContainerHeartbeatDataHorizonPlatform$Outbound = {
   cpu?: MetricSample$Outbound | null | undefined;
   events: Array<ManagedRuntimeEventSnapshot$Outbound>;
   image?: string | null | undefined;
+  latestUpdateTimestamp?: string | null | undefined;
   memory?: MetricSample$Outbound | null | undefined;
+  observedImage?: string | null | undefined;
   replicaUnits: Array<ManagedRuntimeUnitStatus$Outbound>;
   replicas: WorkloadReplicaStatus$Outbound;
   schedulingMode: string;
@@ -235,7 +239,9 @@ export const ContainerHeartbeatDataHorizonPlatform$outboundSchema: z.ZodType<
   cpu: z.nullable(MetricSample$outboundSchema).optional(),
   events: z.array(ManagedRuntimeEventSnapshot$outboundSchema),
   image: z.nullable(z.string()).optional(),
+  latestUpdateTimestamp: z.nullable(z.string()).optional(),
   memory: z.nullable(MetricSample$outboundSchema).optional(),
+  observedImage: z.nullable(z.string()).optional(),
   replicaUnits: z.array(ManagedRuntimeUnitStatus$outboundSchema),
   replicas: WorkloadReplicaStatus$outboundSchema,
   schedulingMode: HorizonWorkloadSchedulingMode$outboundSchema,

package/src/models/createcommandrequest.ts

@@ -33,6 +33,14 @@ export type CreateCommandRequest = {
    * Body specification supporting inline and storage modes
    */
   params: BodySpec;
+  /**
+   * Optional explicit target resource ID within the deployment's stack.
+   *
+   * @remarks
+   * When omitted, the target is resolved server-side (single-target shorthand):
+   * exactly one command-capable resource must exist, or resolution fails.
+   */
+  targetResourceId?: string | null | undefined;
 };
 
 /** @internal */
@@ -42,6 +50,7 @@ export type CreateCommandRequest$Outbound = {
   deploymentId: string;
   idempotencyKey?: string | null | undefined;
   params: BodySpec$Outbound;
+  targetResourceId?: string | null | undefined;
 };
 
 /** @internal */
@@ -54,6 +63,7 @@ export const CreateCommandRequest$outboundSchema: z.ZodType<
   deploymentId: z.string(),
   idempotencyKey: z.nullable(z.string()).optional(),
   params: BodySpec$outboundSchema,
+  targetResourceId: z.nullable(z.string()).optional(),
 });
 
 export function createCommandRequestToJSON(

package/src/models/daemonheartbeatdata.ts

@@ -97,6 +97,7 @@ export type DaemonHeartbeatDataMachines = {
   horizonStatusMessage?: string | null | undefined;
   horizonStatusReason?: string | null | undefined;
   latestUpdateTimestamp: string;
+  observedImage?: string | null | undefined;
   status: WorkloadHeartbeatStatus;
   unavailableInstances: number;
   backend: "machines";
@@ -116,6 +117,7 @@ export type DaemonHeartbeatDataAzure = {
   horizonStatusMessage?: string | null | undefined;
   horizonStatusReason?: string | null | undefined;
   latestUpdateTimestamp: string;
+  observedImage?: string | null | undefined;
   status: WorkloadHeartbeatStatus;
   unavailableInstances: number;
   backend: "azure";
@@ -135,6 +137,7 @@ export type DaemonHeartbeatDataGcp = {
   horizonStatusMessage?: string | null | undefined;
   horizonStatusReason?: string | null | undefined;
   latestUpdateTimestamp: string;
+  observedImage?: string | null | undefined;
   status: WorkloadHeartbeatStatus;
   unavailableInstances: number;
   backend: "gcp";
@@ -154,6 +157,7 @@ export type DaemonHeartbeatDataAws = {
   horizonStatusMessage?: string | null | undefined;
   horizonStatusReason?: string | null | undefined;
   latestUpdateTimestamp: string;
+  observedImage?: string | null | undefined;
   status: WorkloadHeartbeatStatus;
   unavailableInstances: number;
   backend: "aws";
@@ -268,6 +272,7 @@ export type DaemonHeartbeatDataMachines$Outbound = {
   horizonStatusMessage?: string | null | undefined;
   horizonStatusReason?: string | null | undefined;
   latestUpdateTimestamp: string;
+  observedImage?: string | null | undefined;
   status: WorkloadHeartbeatStatus$Outbound;
   unavailableInstances: number;
   backend: "machines";
@@ -291,6 +296,7 @@ export const DaemonHeartbeatDataMachines$outboundSchema: z.ZodType<
   horizonStatusMessage: z.nullable(z.string()).optional(),
   horizonStatusReason: z.nullable(z.string()).optional(),
   latestUpdateTimestamp: z.string(),
+  observedImage: z.nullable(z.string()).optional(),
   status: WorkloadHeartbeatStatus$outboundSchema,
   unavailableInstances: z.int(),
   backend: z.literal("machines"),
@@ -321,6 +327,7 @@ export type DaemonHeartbeatDataAzure$Outbound = {
   horizonStatusMessage?: string | null | undefined;
   horizonStatusReason?: string | null | undefined;
   latestUpdateTimestamp: string;
+  observedImage?: string | null | undefined;
   status: WorkloadHeartbeatStatus$Outbound;
   unavailableInstances: number;
   backend: "azure";
@@ -344,6 +351,7 @@ export const DaemonHeartbeatDataAzure$outboundSchema: z.ZodType<
   horizonStatusMessage: z.nullable(z.string()).optional(),
   horizonStatusReason: z.nullable(z.string()).optional(),
   latestUpdateTimestamp: z.string(),
+  observedImage: z.nullable(z.string()).optional(),
   status: WorkloadHeartbeatStatus$outboundSchema,
   unavailableInstances: z.int(),
   backend: z.literal("azure"),
@@ -372,6 +380,7 @@ export type DaemonHeartbeatDataGcp$Outbound = {
   horizonStatusMessage?: string | null | undefined;
   horizonStatusReason?: string | null | undefined;
   latestUpdateTimestamp: string;
+  observedImage?: string | null | undefined;
   status: WorkloadHeartbeatStatus$Outbound;
   unavailableInstances: number;
   backend: "gcp";
@@ -395,6 +404,7 @@ export const DaemonHeartbeatDataGcp$outboundSchema: z.ZodType<
   horizonStatusMessage: z.nullable(z.string()).optional(),
   horizonStatusReason: z.nullable(z.string()).optional(),
   latestUpdateTimestamp: z.string(),
+  observedImage: z.nullable(z.string()).optional(),
   status: WorkloadHeartbeatStatus$outboundSchema,
   unavailableInstances: z.int(),
   backend: z.literal("gcp"),
@@ -423,6 +433,7 @@ export type DaemonHeartbeatDataAws$Outbound = {
   horizonStatusMessage?: string | null | undefined;
   horizonStatusReason?: string | null | undefined;
   latestUpdateTimestamp: string;
+  observedImage?: string | null | undefined;
   status: WorkloadHeartbeatStatus$Outbound;
   unavailableInstances: number;
   backend: "aws";
@@ -446,6 +457,7 @@ export const DaemonHeartbeatDataAws$outboundSchema: z.ZodType<
   horizonStatusMessage: z.nullable(z.string()).optional(),
   horizonStatusReason: z.nullable(z.string()).optional(),
   latestUpdateTimestamp: z.string(),
+  observedImage: z.nullable(z.string()).optional(),
   status: WorkloadHeartbeatStatus$outboundSchema,
   unavailableInstances: z.int(),
   backend: z.literal("aws"),

package/src/models/envelope.ts

@@ -6,11 +6,13 @@ import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { BodySpec, BodySpec$inboundSchema } from "./bodyspec.js";
+import { CommandTarget, CommandTarget$inboundSchema } from "./commandtarget.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import {
   ResponseHandling,
   ResponseHandling$inboundSchema,
 } from "./responsehandling.js";
+import { TraceContext, TraceContext$inboundSchema } from "./tracecontext.js";
 
 /**
  * Commands envelope sent to deployments
@@ -48,6 +50,11 @@ export type Envelope = {
    * Response handling configuration for deployments
    */
   responseHandling: ResponseHandling;
+  /**
+   * Identifies the specific resource a command is addressed to.
+   */
+  target: CommandTarget;
+  traceContext?: TraceContext | null | undefined;
 };
 
 /** @internal */
@@ -62,6 +69,8 @@ export const Envelope$inboundSchema: z.ZodType<Envelope, unknown> = z.object({
   params: BodySpec$inboundSchema,
   protocol: z.string(),
   responseHandling: ResponseHandling$inboundSchema,
+  target: CommandTarget$inboundSchema,
+  traceContext: z.nullable(TraceContext$inboundSchema).optional(),
 });
 
 export function envelopeFromJSON(

package/src/models/gcpcredentials.ts

@@ -0,0 +1,335 @@
+/*
+ * 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 { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import {
+  GcpImpersonationConfig,
+  GcpImpersonationConfig$inboundSchema,
+} from "./gcpimpersonationconfig.js";
+
+/**
+ * Use gcloud Application Default Credentials (authorized_user).
+ *
+ * @remarks
+ * Exchanges refresh_token for an access_token via Google's OAuth2 endpoint.
+ */
+export type GcpCredentialsAuthorizedUser = {
+  /**
+   * OAuth2 client ID
+   */
+  clientId: string;
+  /**
+   * OAuth2 client secret
+   */
+  clientSecret: string;
+  /**
+   * OAuth2 refresh token
+   */
+  refreshToken: string;
+  type: "authorizedUser";
+};
+
+/**
+ * Use an external account credential configuration.
+ */
+export type GcpCredentialsExternalAccount = {
+  /**
+   * Workload identity audience.
+   */
+  audience: string;
+  /**
+   * Path to the subject token file.
+   */
+  credentialSourceFile: string;
+  /**
+   * Optional service account impersonation URL.
+   */
+  serviceAccountImpersonationUrl?: string | null | undefined;
+  /**
+   * Subject token type for STS token exchange.
+   */
+  subjectTokenType: string;
+  /**
+   * STS token exchange URL.
+   */
+  tokenUrl: string;
+  type: "externalAccount";
+};
+
+/**
+ * Use projected service account token (for Kubernetes workload identity)
+ */
+export type GcpCredentialsProjectedServiceAccount = {
+  /**
+   * Service account email
+   */
+  serviceAccountEmail: string;
+  /**
+   * Path to the projected service account token
+   */
+  tokenFile: string;
+  type: "projectedServiceAccount";
+};
+
+/**
+ * Use GCP metadata server for authentication (for instances running on GCP)
+ */
+export type GcpCredentialsServiceMetadata = {
+  type: "serviceMetadata";
+};
+
+/**
+ * Use a full Service Account JSON key (as string). A short-lived JWT will
+ *
+ * @remarks
+ * be created and exchanged for a bearer token automatically.
+ */
+export type GcpCredentialsServiceAccountKey = {
+  json: string;
+  type: "serviceAccountKey";
+};
+
+/**
+ * Source configuration used to call IAMCredentials.
+ */
+export type Source = {};
+
+/**
+ * Use a refreshable service account impersonation source.
+ */
+export type GcpCredentialsImpersonatedServiceAccount = {
+  /**
+   * Configuration for GCP service account impersonation
+   */
+  config: GcpImpersonationConfig;
+  /**
+   * Source configuration used to call IAMCredentials.
+   */
+  source: Source;
+  type: "impersonatedServiceAccount";
+};
+
+/**
+ * Use an already-minted OAuth2 access token.
+ */
+export type GcpCredentialsAccessToken = {
+  token: string;
+  type: "accessToken";
+};
+
+/**
+ * Authentication options for talking to GCP APIs.
+ */
+export type GcpCredentials =
+  | GcpCredentialsAccessToken
+  | GcpCredentialsImpersonatedServiceAccount
+  | GcpCredentialsServiceAccountKey
+  | GcpCredentialsServiceMetadata
+  | GcpCredentialsProjectedServiceAccount
+  | GcpCredentialsExternalAccount
+  | GcpCredentialsAuthorizedUser;
+
+/** @internal */
+export const GcpCredentialsAuthorizedUser$inboundSchema: z.ZodType<
+  GcpCredentialsAuthorizedUser,
+  unknown
+> = z.object({
+  client_id: z.string(),
+  client_secret: z.string(),
+  refresh_token: z.string(),
+  type: z.literal("authorizedUser"),
+}).transform((v) => {
+  return remap$(v, {
+    "client_id": "clientId",
+    "client_secret": "clientSecret",
+    "refresh_token": "refreshToken",
+  });
+});
+
+export function gcpCredentialsAuthorizedUserFromJSON(
+  jsonString: string,
+): SafeParseResult<GcpCredentialsAuthorizedUser, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GcpCredentialsAuthorizedUser$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GcpCredentialsAuthorizedUser' from JSON`,
+  );
+}
+
+/** @internal */
+export const GcpCredentialsExternalAccount$inboundSchema: z.ZodType<
+  GcpCredentialsExternalAccount,
+  unknown
+> = z.object({
+  audience: z.string(),
+  credential_source_file: z.string(),
+  service_account_impersonation_url: z.nullable(z.string()).optional(),
+  subject_token_type: z.string(),
+  token_url: z.string(),
+  type: z.literal("externalAccount"),
+}).transform((v) => {
+  return remap$(v, {
+    "credential_source_file": "credentialSourceFile",
+    "service_account_impersonation_url": "serviceAccountImpersonationUrl",
+    "subject_token_type": "subjectTokenType",
+    "token_url": "tokenUrl",
+  });
+});
+
+export function gcpCredentialsExternalAccountFromJSON(
+  jsonString: string,
+): SafeParseResult<GcpCredentialsExternalAccount, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GcpCredentialsExternalAccount$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GcpCredentialsExternalAccount' from JSON`,
+  );
+}
+
+/** @internal */
+export const GcpCredentialsProjectedServiceAccount$inboundSchema: z.ZodType<
+  GcpCredentialsProjectedServiceAccount,
+  unknown
+> = z.object({
+  service_account_email: z.string(),
+  token_file: z.string(),
+  type: z.literal("projectedServiceAccount"),
+}).transform((v) => {
+  return remap$(v, {
+    "service_account_email": "serviceAccountEmail",
+    "token_file": "tokenFile",
+  });
+});
+
+export function gcpCredentialsProjectedServiceAccountFromJSON(
+  jsonString: string,
+): SafeParseResult<GcpCredentialsProjectedServiceAccount, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GcpCredentialsProjectedServiceAccount$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GcpCredentialsProjectedServiceAccount' from JSON`,
+  );
+}
+
+/** @internal */
+export const GcpCredentialsServiceMetadata$inboundSchema: z.ZodType<
+  GcpCredentialsServiceMetadata,
+  unknown
+> = z.object({
+  type: z.literal("serviceMetadata"),
+});
+
+export function gcpCredentialsServiceMetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<GcpCredentialsServiceMetadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GcpCredentialsServiceMetadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GcpCredentialsServiceMetadata' from JSON`,
+  );
+}
+
+/** @internal */
+export const GcpCredentialsServiceAccountKey$inboundSchema: z.ZodType<
+  GcpCredentialsServiceAccountKey,
+  unknown
+> = z.object({
+  json: z.string(),
+  type: z.literal("serviceAccountKey"),
+});
+
+export function gcpCredentialsServiceAccountKeyFromJSON(
+  jsonString: string,
+): SafeParseResult<GcpCredentialsServiceAccountKey, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GcpCredentialsServiceAccountKey$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GcpCredentialsServiceAccountKey' from JSON`,
+  );
+}
+
+/** @internal */
+export const Source$inboundSchema: z.ZodType<Source, unknown> = z.object({});
+
+export function sourceFromJSON(
+  jsonString: string,
+): SafeParseResult<Source, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Source$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Source' from JSON`,
+  );
+}
+
+/** @internal */
+export const GcpCredentialsImpersonatedServiceAccount$inboundSchema: z.ZodType<
+  GcpCredentialsImpersonatedServiceAccount,
+  unknown
+> = z.object({
+  config: GcpImpersonationConfig$inboundSchema,
+  source: z.lazy(() => Source$inboundSchema),
+  type: z.literal("impersonatedServiceAccount"),
+});
+
+export function gcpCredentialsImpersonatedServiceAccountFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GcpCredentialsImpersonatedServiceAccount,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GcpCredentialsImpersonatedServiceAccount$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GcpCredentialsImpersonatedServiceAccount' from JSON`,
+  );
+}
+
+/** @internal */
+export const GcpCredentialsAccessToken$inboundSchema: z.ZodType<
+  GcpCredentialsAccessToken,
+  unknown
+> = z.object({
+  token: z.string(),
+  type: z.literal("accessToken"),
+});
+
+export function gcpCredentialsAccessTokenFromJSON(
+  jsonString: string,
+): SafeParseResult<GcpCredentialsAccessToken, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GcpCredentialsAccessToken$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GcpCredentialsAccessToken' from JSON`,
+  );
+}
+
+/** @internal */
+export const GcpCredentials$inboundSchema: z.ZodType<GcpCredentials, unknown> =
+  z.union([
+    z.lazy(() => GcpCredentialsAccessToken$inboundSchema),
+    z.lazy(() => GcpCredentialsImpersonatedServiceAccount$inboundSchema),
+    z.lazy(() => GcpCredentialsServiceAccountKey$inboundSchema),
+    z.lazy(() => GcpCredentialsServiceMetadata$inboundSchema),
+    z.lazy(() => GcpCredentialsProjectedServiceAccount$inboundSchema),
+    z.lazy(() => GcpCredentialsExternalAccount$inboundSchema),
+    z.lazy(() => GcpCredentialsAuthorizedUser$inboundSchema),
+  ]);
+
+export function gcpCredentialsFromJSON(
+  jsonString: string,
+): SafeParseResult<GcpCredentials, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GcpCredentials$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GcpCredentials' from JSON`,
+  );
+}

package/src/models/gcpimpersonationconfig.ts

@@ -0,0 +1,67 @@
+/*
+ * 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";
+
+/**
+ * Configuration for GCP service account impersonation
+ */
+export type GcpImpersonationConfig = {
+  /**
+   * Optional sequence of service accounts in a delegation chain
+   */
+  delegates?: Array<string> | null | undefined;
+  /**
+   * Optional desired lifetime duration of the access token (max 3600s)
+   */
+  lifetime?: string | null | undefined;
+  /**
+   * The OAuth 2.0 scopes that define the access token's permissions
+   */
+  scopes: Array<string>;
+  /**
+   * The email of the service account to impersonate
+   */
+  serviceAccountEmail: string;
+  /**
+   * Optional target project ID override. When provided, the impersonated config
+   *
+   * @remarks
+   * uses this project ID instead of inheriting the caller's project.
+   */
+  targetProjectId?: string | null | undefined;
+  /**
+   * Optional target region override. When provided, the impersonated config
+   *
+   * @remarks
+   * uses this region instead of inheriting the caller's region.
+   */
+  targetRegion?: string | null | undefined;
+};
+
+/** @internal */
+export const GcpImpersonationConfig$inboundSchema: z.ZodType<
+  GcpImpersonationConfig,
+  unknown
+> = z.object({
+  delegates: z.nullable(z.array(z.string())).optional(),
+  lifetime: z.nullable(z.string()).optional(),
+  scopes: z.array(z.string()),
+  serviceAccountEmail: z.string(),
+  targetProjectId: z.nullable(z.string()).optional(),
+  targetRegion: z.nullable(z.string()).optional(),
+});
+
+export function gcpImpersonationConfigFromJSON(
+  jsonString: string,
+): SafeParseResult<GcpImpersonationConfig, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GcpImpersonationConfig$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GcpImpersonationConfig' from JSON`,
+  );
+}

package/src/models/gcpserviceoverrides.ts

@@ -0,0 +1,39 @@
+/*
+ * 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";
+
+/**
+ * Service endpoint overrides for testing GCP services
+ */
+export type GcpServiceOverrides = {
+  /**
+   * Override endpoints for specific GCP services
+   *
+   * @remarks
+   * Key is the service name (e.g., "cloudrun", "storage"), value is the base URL
+   */
+  endpoints: { [k: string]: string };
+};
+
+/** @internal */
+export const GcpServiceOverrides$inboundSchema: z.ZodType<
+  GcpServiceOverrides,
+  unknown
+> = z.object({
+  endpoints: z.record(z.string(), z.string()),
+});
+
+export function gcpServiceOverridesFromJSON(
+  jsonString: string,
+): SafeParseResult<GcpServiceOverrides, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GcpServiceOverrides$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GcpServiceOverrides' from JSON`,
+  );
+}