@alienplatform/manager-api 3.3.25 → 3.3.27

package/src/models/agentsyncrequest.ts

@@ -3,6 +3,11 @@
  */
 
 import * as z from "zod/v4";
+import {
+  DynamicContainerReport,
+  DynamicContainerReport$Outbound,
+  DynamicContainerReport$outboundSchema,
+} from "./dynamiccontainerreport.js";
 import {
   ExecutionClaim,
   ExecutionClaim$Outbound,
@@ -63,7 +68,15 @@ export type AgentSyncRequest = {
   resourceHeartbeats?: Array<ResourceHeartbeat> | undefined;
   session?: string | undefined;
   supportsExecutionClaims?: boolean | undefined;
+  /**
+   * Absent for Operators that predate container tunnels.
+   */
+  supportsTunnels?: boolean | undefined;
   application?: ObservedApplicationReport | null | undefined;
+  /**
+   * Absent for older Operators. This report has no secret values.
+   */
+  dynamicContainers?: Array<DynamicContainerReport> | null | undefined;
   operatorImage?: OperatorImageReport | null | undefined;
 };
 
@@ -79,7 +92,9 @@ export type AgentSyncRequest$Outbound = {
   resourceHeartbeats?: Array<ResourceHeartbeat$Outbound> | undefined;
   session?: string | undefined;
   supportsExecutionClaims?: boolean | undefined;
+  supportsTunnels?: boolean | undefined;
   application?: ObservedApplicationReport$Outbound | null | undefined;
+  dynamicContainers?: Array<DynamicContainerReport$Outbound> | null | undefined;
   operatorImage?: OperatorImageReport$Outbound | null | undefined;
 };
 
@@ -99,7 +114,10 @@ export const AgentSyncRequest$outboundSchema: z.ZodType<
   resourceHeartbeats: z.array(ResourceHeartbeat$outboundSchema).optional(),
   session: z.string().optional(),
   supportsExecutionClaims: z.boolean().optional(),
+  supportsTunnels: z.boolean().optional(),
   application: z.nullable(ObservedApplicationReport$outboundSchema).optional(),
+  dynamicContainers: z.nullable(z.array(DynamicContainerReport$outboundSchema))
+    .optional(),
   operatorImage: z.nullable(OperatorImageReport$outboundSchema).optional(),
 });
 

package/src/models/agentsyncresponse.ts

@@ -10,6 +10,10 @@ import {
   ExecutionClaim,
   ExecutionClaim$inboundSchema,
 } from "./executionclaim.js";
+import {
+  TargetDynamicContainer,
+  TargetDynamicContainer$inboundSchema,
+} from "./targetdynamiccontainer.js";
 import {
   TargetOperationsBundleSet,
   TargetOperationsBundleSet$inboundSchema,
@@ -34,7 +38,26 @@ export type AgentSyncResponse = {
   currentState?: any | undefined;
   executionClaim?: ExecutionClaim | null | undefined;
   target?: any | undefined;
+  /**
+   * Complete release-independent target set. Older embedders omit it.
+   */
+  targetDynamicContainers?: Array<TargetDynamicContainer> | null | undefined;
   targetOperationsBundleSet?: TargetOperationsBundleSet | null | undefined;
+  /**
+   * Operator image this manager's charts install. Operators that manage
+   *
+   * @remarks
+   * their own workload update to it. Absent when the manager serves no
+   * charts.
+   */
+  targetOperatorImage?: string | null | undefined;
+  /**
+   * Base URL operators open tunnel connections to. Absent when this manager
+   *
+   * @remarks
+   * does not accept tunnels; operators then never dial.
+   */
+  tunnelUrl?: string | null | undefined;
 };
 
 /** @internal */
@@ -46,8 +69,13 @@ export const AgentSyncResponse$inboundSchema: z.ZodType<
   currentState: z.any().optional(),
   executionClaim: z.nullable(ExecutionClaim$inboundSchema).optional(),
   target: z.any().optional(),
+  targetDynamicContainers: z.nullable(
+    z.array(TargetDynamicContainer$inboundSchema),
+  ).optional(),
   targetOperationsBundleSet: z.nullable(TargetOperationsBundleSet$inboundSchema)
     .optional(),
+  targetOperatorImage: z.nullable(z.string()).optional(),
+  tunnelUrl: z.nullable(z.string()).optional(),
 });
 
 export function agentSyncResponseFromJSON(

package/src/models/awscredentials.ts

@@ -34,6 +34,28 @@ export type AwsCredentialsProfile = {
   type: "profile";
 };
 
+/**
+ * Container credentials endpoint: ECS task roles and EKS Pod Identity.
+ */
+export type AwsCredentialsContainer = {
+  /**
+   * Authorization header value for the endpoint
+   */
+  authorizationToken?: string | null | undefined;
+  /**
+   * File holding the authorization header value, re-read on each
+   *
+   * @remarks
+   * refresh because the platform rotates it
+   */
+  authorizationTokenFile?: string | null | undefined;
+  /**
+   * Credentials endpoint URL
+   */
+  endpoint: string;
+  type: "container";
+};
+
 /**
  * AWS Instance Metadata Service credentials.
  */
@@ -94,6 +116,7 @@ export type AwsCredentials =
   | AwsCredentialsAccessKeys
   | AwsCredentialsSessionCredentials
   | AwsCredentialsImds
+  | AwsCredentialsContainer
   | AwsCredentialsProfile
   | AwsCredentialsWebIdentity;
 
@@ -135,6 +158,32 @@ export function awsCredentialsProfileFromJSON(
   );
 }
 
+/** @internal */
+export const AwsCredentialsContainer$inboundSchema: z.ZodType<
+  AwsCredentialsContainer,
+  unknown
+> = z.object({
+  authorization_token: z.nullable(z.string()).optional(),
+  authorization_token_file: z.nullable(z.string()).optional(),
+  endpoint: z.string(),
+  type: z.literal("container"),
+}).transform((v) => {
+  return remap$(v, {
+    "authorization_token": "authorizationToken",
+    "authorization_token_file": "authorizationTokenFile",
+  });
+});
+
+export function awsCredentialsContainerFromJSON(
+  jsonString: string,
+): SafeParseResult<AwsCredentialsContainer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AwsCredentialsContainer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AwsCredentialsContainer' from JSON`,
+  );
+}
+
 /** @internal */
 export const AwsCredentialsImds$inboundSchema: z.ZodType<
   AwsCredentialsImds,
@@ -216,6 +265,7 @@ export const AwsCredentials$inboundSchema: z.ZodType<AwsCredentials, unknown> =
     z.lazy(() => AwsCredentialsAccessKeys$inboundSchema),
     z.lazy(() => AwsCredentialsSessionCredentials$inboundSchema),
     z.lazy(() => AwsCredentialsImds$inboundSchema),
+    z.lazy(() => AwsCredentialsContainer$inboundSchema),
     z.lazy(() => AwsCredentialsProfile$inboundSchema),
     z.lazy(() => AwsCredentialsWebIdentity$inboundSchema),
   ]);

package/src/models/bundlesignaturerequest.ts

@@ -0,0 +1,36 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+
+/**
+ * Body of `POST /v1/deployments/{id}/bundle-signature`.
+ */
+export type BundleSignatureRequest = {
+  /**
+   * The bundle's `manifest.json`, base64-encoded, exactly as packaged.
+   */
+  manifest: string;
+};
+
+/** @internal */
+export type BundleSignatureRequest$Outbound = {
+  manifest: string;
+};
+
+/** @internal */
+export const BundleSignatureRequest$outboundSchema: z.ZodType<
+  BundleSignatureRequest$Outbound,
+  BundleSignatureRequest
+> = z.object({
+  manifest: z.string(),
+});
+
+export function bundleSignatureRequestToJSON(
+  bundleSignatureRequest: BundleSignatureRequest,
+): string {
+  return JSON.stringify(
+    BundleSignatureRequest$outboundSchema.parse(bundleSignatureRequest),
+  );
+}

package/src/models/bundlesignatureresponse.ts

@@ -0,0 +1,41 @@
+/*
+ * 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";
+
+/**
+ * A signature over a bundle manifest.
+ */
+export type BundleSignatureResponse = {
+  /**
+   * `ed25519:<base64>` public key that verifies it.
+   */
+  publicKey: string;
+  /**
+   * `ed25519:<base64>` signature over the manifest bytes.
+   */
+  signature: string;
+};
+
+/** @internal */
+export const BundleSignatureResponse$inboundSchema: z.ZodType<
+  BundleSignatureResponse,
+  unknown
+> = z.object({
+  publicKey: z.string(),
+  signature: z.string(),
+});
+
+export function bundleSignatureResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<BundleSignatureResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BundleSignatureResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BundleSignatureResponse' from JSON`,
+  );
+}

package/src/models/bundlesource.ts

@@ -0,0 +1,37 @@
+/*
+ * 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";
+import {
+  SourceCredentials,
+  SourceCredentials$inboundSchema,
+} from "./sourcecredentials.js";
+
+/**
+ * One OCI artifact and how to authenticate when pulling it.
+ */
+export type BundleSource = {
+  credentials: SourceCredentials;
+  reference: string;
+};
+
+/** @internal */
+export const BundleSource$inboundSchema: z.ZodType<BundleSource, unknown> = z
+  .object({
+    credentials: SourceCredentials$inboundSchema,
+    reference: z.string(),
+  });
+
+export function bundleSourceFromJSON(
+  jsonString: string,
+): SafeParseResult<BundleSource, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BundleSource$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BundleSource' from JSON`,
+  );
+}

package/src/models/bundlesources.ts

@@ -0,0 +1,41 @@
+/*
+ * 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 { BundleSource, BundleSource$inboundSchema } from "./bundlesource.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ToolDownload, ToolDownload$inboundSchema } from "./tooldownload.js";
+
+/**
+ * The artifacts a bundle carries besides the release's own images.
+ */
+export type BundleSources = {
+  /**
+   * One OCI artifact and how to authenticate when pulling it.
+   */
+  chart: BundleSource;
+  /**
+   * `alien-deploy` builds for the site, matching this manager.
+   */
+  deployCli?: Array<ToolDownload> | undefined;
+};
+
+/** @internal */
+export const BundleSources$inboundSchema: z.ZodType<BundleSources, unknown> = z
+  .object({
+    chart: BundleSource$inboundSchema,
+    deployCli: z.array(ToolDownload$inboundSchema).optional(),
+  });
+
+export function bundleSourcesFromJSON(
+  jsonString: string,
+): SafeParseResult<BundleSources, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BundleSources$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BundleSources' from JSON`,
+  );
+}

package/src/models/creatabletokentype.ts

@@ -0,0 +1,22 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+
+/**
+ * Token kinds an admin can create through the API.
+ */
+export const CreatableTokenType = {
+  Tunnel: "tunnel",
+} as const;
+/**
+ * Token kinds an admin can create through the API.
+ */
+export type CreatableTokenType = ClosedEnum<typeof CreatableTokenType>;
+
+/** @internal */
+export const CreatableTokenType$outboundSchema: z.ZodEnum<
+  typeof CreatableTokenType
+> = z.enum(CreatableTokenType);

package/src/models/createdeploymentgrouprequest.ts

@@ -3,14 +3,29 @@
  */
 
 import * as z from "zod/v4";
+import {
+  EnvironmentVariable,
+  EnvironmentVariable$Outbound,
+  EnvironmentVariable$outboundSchema,
+} from "./environmentvariable.js";
 
 export type CreateDeploymentGroupRequest = {
+  /**
+   * Environment variables applied to each deployment the group creates.
+   */
+  environmentVariables?: Array<EnvironmentVariable> | undefined;
+  /**
+   * Stack input values applied to each deployment the group creates.
+   */
+  inputValues?: { [k: string]: any } | undefined;
   maxDeployments?: number | undefined;
   name: string;
 };
 
 /** @internal */
 export type CreateDeploymentGroupRequest$Outbound = {
+  environmentVariables?: Array<EnvironmentVariable$Outbound> | undefined;
+  inputValues?: { [k: string]: any } | undefined;
   maxDeployments?: number | undefined;
   name: string;
 };
@@ -20,6 +35,8 @@ export const CreateDeploymentGroupRequest$outboundSchema: z.ZodType<
   CreateDeploymentGroupRequest$Outbound,
   CreateDeploymentGroupRequest
 > = z.object({
+  environmentVariables: z.array(EnvironmentVariable$outboundSchema).optional(),
+  inputValues: z.record(z.string(), z.any()).optional(),
   maxDeployments: z.int().optional(),
   name: z.string(),
 });

package/src/models/createdeploymentrequest.ts

@@ -18,6 +18,13 @@ import {
 export type CreateDeploymentRequest = {
   deploymentGroupId?: string | null | undefined;
   environmentVariables?: Array<EnvironmentVariable> | null | undefined;
+  /**
+   * Stack input values, by input name. Stored with the deployment and read by every
+   *
+   * @remarks
+   * deployment step, like the values a setup collects.
+   */
+  inputValues?: { [k: string]: any } | undefined;
   name: string;
   /**
    * Represents the target cloud platform.
@@ -31,6 +38,7 @@ export type CreateDeploymentRequest = {
 export type CreateDeploymentRequest$Outbound = {
   deploymentGroupId?: string | null | undefined;
   environmentVariables?: Array<EnvironmentVariable$Outbound> | null | undefined;
+  inputValues?: { [k: string]: any } | undefined;
   name: string;
   platform: string;
   resourcePrefix?: string | null | undefined;
@@ -45,6 +53,7 @@ export const CreateDeploymentRequest$outboundSchema: z.ZodType<
   deploymentGroupId: z.nullable(z.string()).optional(),
   environmentVariables: z.nullable(z.array(EnvironmentVariable$outboundSchema))
     .optional(),
+  inputValues: z.record(z.string(), z.any()).optional(),
   name: z.string(),
   platform: PlatformEnum$outboundSchema,
   resourcePrefix: z.nullable(z.string()).optional(),

package/src/models/createdtokenresponse.ts

@@ -0,0 +1,45 @@
+/*
+ * 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 CreatedTokenResponse = {
+  createdAt: string;
+  deploymentGroupId?: string | null | undefined;
+  deploymentId?: string | null | undefined;
+  id: string;
+  keyPrefix: string;
+  tokenType: string;
+  /**
+   * The raw token. Shown once; only its hash is stored.
+   */
+  token: string;
+};
+
+/** @internal */
+export const CreatedTokenResponse$inboundSchema: z.ZodType<
+  CreatedTokenResponse,
+  unknown
+> = z.object({
+  createdAt: z.string(),
+  deploymentGroupId: z.nullable(z.string()).optional(),
+  deploymentId: z.nullable(z.string()).optional(),
+  id: z.string(),
+  keyPrefix: z.string(),
+  tokenType: z.string(),
+  token: z.string(),
+});
+
+export function createdTokenResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CreatedTokenResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreatedTokenResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreatedTokenResponse' from JSON`,
+  );
+}

package/src/models/createreleasechannelrequest.ts

@@ -0,0 +1,44 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+
+/**
+ * Body of `POST /v1/release-channels`.
+ */
+export type CreateReleaseChannelRequest = {
+  /**
+   * Lowercase letters, digits and hyphens, starting with a letter.
+   */
+  name: string;
+  /**
+   * Release the channel starts at.
+   */
+  releaseId?: string | null | undefined;
+};
+
+/** @internal */
+export type CreateReleaseChannelRequest$Outbound = {
+  name: string;
+  releaseId?: string | null | undefined;
+};
+
+/** @internal */
+export const CreateReleaseChannelRequest$outboundSchema: z.ZodType<
+  CreateReleaseChannelRequest$Outbound,
+  CreateReleaseChannelRequest
+> = z.object({
+  name: z.string(),
+  releaseId: z.nullable(z.string()).optional(),
+});
+
+export function createReleaseChannelRequestToJSON(
+  createReleaseChannelRequest: CreateReleaseChannelRequest,
+): string {
+  return JSON.stringify(
+    CreateReleaseChannelRequest$outboundSchema.parse(
+      createReleaseChannelRequest,
+    ),
+  );
+}

package/src/models/createreleaserequest.ts

@@ -15,6 +15,13 @@ import {
 } from "./stackbyplatform.js";
 
 export type CreateReleaseRequest = {
+  /**
+   * Channel the release advances; `production` when absent. Deployments
+   *
+   * @remarks
+   * following the channel roll out to it.
+   */
+  channel?: string | null | undefined;
   gitMetadata?: GitMetadata | null | undefined;
   /**
    * Project this release belongs to. Required. The standalone server
@@ -41,6 +48,7 @@ export type CreateReleaseRequest = {
 
 /** @internal */
 export type CreateReleaseRequest$Outbound = {
+  channel?: string | null | undefined;
   gitMetadata?: GitMetadata$Outbound | null | undefined;
   projectId: string;
   stack: StackByPlatform$Outbound;
@@ -51,6 +59,7 @@ export const CreateReleaseRequest$outboundSchema: z.ZodType<
   CreateReleaseRequest$Outbound,
   CreateReleaseRequest
 > = z.object({
+  channel: z.nullable(z.string()).optional(),
   gitMetadata: z.nullable(GitMetadata$outboundSchema).optional(),
   projectId: z.string(),
   stack: StackByPlatform$outboundSchema,

package/src/models/createtokenrequest.ts

@@ -0,0 +1,43 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import {
+  CreatableTokenType,
+  CreatableTokenType$outboundSchema,
+} from "./creatabletokentype.js";
+
+export type CreateTokenRequest = {
+  /**
+   * Limit the token to one deployment group's deployments.
+   */
+  deploymentGroupId?: string | null | undefined;
+  /**
+   * Token kinds an admin can create through the API.
+   */
+  type: CreatableTokenType;
+};
+
+/** @internal */
+export type CreateTokenRequest$Outbound = {
+  deploymentGroupId?: string | null | undefined;
+  type: string;
+};
+
+/** @internal */
+export const CreateTokenRequest$outboundSchema: z.ZodType<
+  CreateTokenRequest$Outbound,
+  CreateTokenRequest
+> = z.object({
+  deploymentGroupId: z.nullable(z.string()).optional(),
+  type: CreatableTokenType$outboundSchema,
+});
+
+export function createTokenRequestToJSON(
+  createTokenRequest: CreateTokenRequest,
+): string {
+  return JSON.stringify(
+    CreateTokenRequest$outboundSchema.parse(createTokenRequest),
+  );
+}

package/src/models/deploymentroutingresponse.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 { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+/**
+ * What a deployment follows and the release that makes it run.
+ */
+export type DeploymentRoutingResponse = {
+  channel: string;
+  deploymentId: string;
+  pinnedReleaseId?: string | null | undefined;
+  /**
+   * The release the deployment is sent: the pin, else the channel's release.
+   */
+  releaseId?: string | null | undefined;
+};
+
+/** @internal */
+export const DeploymentRoutingResponse$inboundSchema: z.ZodType<
+  DeploymentRoutingResponse,
+  unknown
+> = z.object({
+  channel: z.string(),
+  deploymentId: z.string(),
+  pinnedReleaseId: z.nullable(z.string()).optional(),
+  releaseId: z.nullable(z.string()).optional(),
+});
+
+export function deploymentRoutingResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentRoutingResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentRoutingResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentRoutingResponse' from JSON`,
+  );
+}

package/src/models/dynamiccontainerhealthcheck.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 DynamicContainerHealthCheck = {
+  path: string;
+  port: number;
+};
+
+/** @internal */
+export const DynamicContainerHealthCheck$inboundSchema: z.ZodType<
+  DynamicContainerHealthCheck,
+  unknown
+> = z.object({
+  path: z.string(),
+  port: z.int(),
+});
+
+export function dynamicContainerHealthCheckFromJSON(
+  jsonString: string,
+): SafeParseResult<DynamicContainerHealthCheck, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DynamicContainerHealthCheck$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DynamicContainerHealthCheck' from JSON`,
+  );
+}