@alienplatform/manager-api 3.3.0 → 3.3.2

package/src/lib/security.ts

@@ -13,22 +13,17 @@ type OAuth2PasswordFlow = {
   tokenURL: string;
 };
 
-export const SecurityErrorCode = {
-  Incomplete: "incomplete",
-  UnrecognisedSecurityType: "unrecognized_security_type",
-} as const;
-export type SecurityErrorCode =
-  (typeof SecurityErrorCode)[keyof typeof SecurityErrorCode];
+export enum SecurityErrorCode {
+  Incomplete = "incomplete",
+  UnrecognisedSecurityType = "unrecognized_security_type",
+}
 
 export class SecurityError extends Error {
-  public code: SecurityErrorCode;
-
   constructor(
-    code: SecurityErrorCode,
+    public code: SecurityErrorCode,
     message: string,
   ) {
     super(message);
-    this.code = code;
     this.name = "SecurityError";
   }
 
@@ -203,7 +198,8 @@ export function resolveSecurity(
         applyBearer(state, spec);
         break;
       default:
-        throw SecurityError.unrecognizedType((spec satisfies never, type));
+        spec satisfies never;
+        throw SecurityError.unrecognizedType(type);
     }
   });
 
@@ -245,28 +241,16 @@ function applyBearer(
 
 export function resolveGlobalSecurity(
   security: Partial<models.Security> | null | undefined,
-  allowedFields?: number[],
 ): SecurityState | null {
-  let inputs: SecurityInput[][] = [
+  return resolveSecurity(
     [
       {
         fieldName: "Authorization",
-        type: "apiKey:header",
+        type: "http:bearer",
         value: security?.bearer ?? env().ALIEN_MANAGER_BEARER,
       },
     ],
-  ];
-
-  if (allowedFields) {
-    inputs = allowedFields.map((i) => {
-      if (i < 0 || i >= inputs.length) {
-        throw new RangeError(`invalid allowedFields index ${i}`);
-      }
-      return inputs[i]!;
-    });
-  }
-
-  return resolveSecurity(...inputs);
+  );
 }
 
 export async function extractSecurity<

package/src/lib/url.ts

@@ -13,23 +13,21 @@ export function pathToFunc(
   const paramRE = /\{([a-zA-Z0-9_][a-zA-Z0-9_-]*?)\}/g;
 
   return function buildURLPath(params: Record<string, unknown> = {}): string {
-    return pathPattern
-      .replace(paramRE, function (_, placeholder) {
-        if (!hasOwn.call(params, placeholder)) {
-          throw new Error(`Parameter '${placeholder}' is required`);
-        }
+    return pathPattern.replace(paramRE, function (_, placeholder) {
+      if (!hasOwn.call(params, placeholder)) {
+        throw new Error(`Parameter '${placeholder}' is required`);
+      }
 
-        const value = params[placeholder];
-        if (typeof value !== "string" && typeof value !== "number") {
-          throw new Error(
-            `Parameter '${placeholder}' must be a string or number`,
-          );
-        }
+      const value = params[placeholder];
+      if (typeof value !== "string" && typeof value !== "number") {
+        throw new Error(
+          `Parameter '${placeholder}' must be a string or number`,
+        );
+      }
 
-        return options?.charEncoding === "percent"
-          ? encodeURIComponent(`${value}`)
-          : `${value}`;
-      })
-      .replace(/^\/+/, "");
+      return options?.charEncoding === "percent"
+        ? encodeURIComponent(`${value}`)
+        : `${value}`;
+    });
   };
 }

package/src/models/aiheartbeatdata.ts

@@ -0,0 +1,184 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import {
+  AiHeartbeatStatus,
+  AiHeartbeatStatus$Outbound,
+  AiHeartbeatStatus$outboundSchema,
+} from "./aiheartbeatstatus.js";
+
+export type AiHeartbeatDataExternal = {
+  /**
+   * The BYO-key provider serving this binding (e.g. "openai"). Used on the Local
+   *
+   * @remarks
+   * platform, where the app brings its own provider key instead of an ambient cloud.
+   */
+  provider: string;
+  status: AiHeartbeatStatus;
+  backend: "external";
+};
+
+export type AiHeartbeatDataAzureFoundry = {
+  accountName: string;
+  endpoint?: string | null | undefined;
+  location?: string | null | undefined;
+  resourceGroup?: string | null | undefined;
+  status: AiHeartbeatStatus;
+  backend: "azureFoundry";
+};
+
+export type AiHeartbeatDataGcpVertex = {
+  location: string;
+  project: string;
+  status: AiHeartbeatStatus;
+  backend: "gcpVertex";
+};
+
+export type AiHeartbeatDataAwsBedrock = {
+  region: string;
+  status: AiHeartbeatStatus;
+  backend: "awsBedrock";
+};
+
+export type AiHeartbeatData =
+  | AiHeartbeatDataAwsBedrock
+  | AiHeartbeatDataGcpVertex
+  | AiHeartbeatDataAzureFoundry
+  | AiHeartbeatDataExternal;
+
+/** @internal */
+export type AiHeartbeatDataExternal$Outbound = {
+  provider: string;
+  status: AiHeartbeatStatus$Outbound;
+  backend: "external";
+};
+
+/** @internal */
+export const AiHeartbeatDataExternal$outboundSchema: z.ZodType<
+  AiHeartbeatDataExternal$Outbound,
+  AiHeartbeatDataExternal
+> = z.object({
+  provider: z.string(),
+  status: AiHeartbeatStatus$outboundSchema,
+  backend: z.literal("external"),
+});
+
+export function aiHeartbeatDataExternalToJSON(
+  aiHeartbeatDataExternal: AiHeartbeatDataExternal,
+): string {
+  return JSON.stringify(
+    AiHeartbeatDataExternal$outboundSchema.parse(aiHeartbeatDataExternal),
+  );
+}
+
+/** @internal */
+export type AiHeartbeatDataAzureFoundry$Outbound = {
+  accountName: string;
+  endpoint?: string | null | undefined;
+  location?: string | null | undefined;
+  resourceGroup?: string | null | undefined;
+  status: AiHeartbeatStatus$Outbound;
+  backend: "azureFoundry";
+};
+
+/** @internal */
+export const AiHeartbeatDataAzureFoundry$outboundSchema: z.ZodType<
+  AiHeartbeatDataAzureFoundry$Outbound,
+  AiHeartbeatDataAzureFoundry
+> = z.object({
+  accountName: z.string(),
+  endpoint: z.nullable(z.string()).optional(),
+  location: z.nullable(z.string()).optional(),
+  resourceGroup: z.nullable(z.string()).optional(),
+  status: AiHeartbeatStatus$outboundSchema,
+  backend: z.literal("azureFoundry"),
+});
+
+export function aiHeartbeatDataAzureFoundryToJSON(
+  aiHeartbeatDataAzureFoundry: AiHeartbeatDataAzureFoundry,
+): string {
+  return JSON.stringify(
+    AiHeartbeatDataAzureFoundry$outboundSchema.parse(
+      aiHeartbeatDataAzureFoundry,
+    ),
+  );
+}
+
+/** @internal */
+export type AiHeartbeatDataGcpVertex$Outbound = {
+  location: string;
+  project: string;
+  status: AiHeartbeatStatus$Outbound;
+  backend: "gcpVertex";
+};
+
+/** @internal */
+export const AiHeartbeatDataGcpVertex$outboundSchema: z.ZodType<
+  AiHeartbeatDataGcpVertex$Outbound,
+  AiHeartbeatDataGcpVertex
+> = z.object({
+  location: z.string(),
+  project: z.string(),
+  status: AiHeartbeatStatus$outboundSchema,
+  backend: z.literal("gcpVertex"),
+});
+
+export function aiHeartbeatDataGcpVertexToJSON(
+  aiHeartbeatDataGcpVertex: AiHeartbeatDataGcpVertex,
+): string {
+  return JSON.stringify(
+    AiHeartbeatDataGcpVertex$outboundSchema.parse(aiHeartbeatDataGcpVertex),
+  );
+}
+
+/** @internal */
+export type AiHeartbeatDataAwsBedrock$Outbound = {
+  region: string;
+  status: AiHeartbeatStatus$Outbound;
+  backend: "awsBedrock";
+};
+
+/** @internal */
+export const AiHeartbeatDataAwsBedrock$outboundSchema: z.ZodType<
+  AiHeartbeatDataAwsBedrock$Outbound,
+  AiHeartbeatDataAwsBedrock
+> = z.object({
+  region: z.string(),
+  status: AiHeartbeatStatus$outboundSchema,
+  backend: z.literal("awsBedrock"),
+});
+
+export function aiHeartbeatDataAwsBedrockToJSON(
+  aiHeartbeatDataAwsBedrock: AiHeartbeatDataAwsBedrock,
+): string {
+  return JSON.stringify(
+    AiHeartbeatDataAwsBedrock$outboundSchema.parse(aiHeartbeatDataAwsBedrock),
+  );
+}
+
+/** @internal */
+export type AiHeartbeatData$Outbound =
+  | AiHeartbeatDataAwsBedrock$Outbound
+  | AiHeartbeatDataGcpVertex$Outbound
+  | AiHeartbeatDataAzureFoundry$Outbound
+  | AiHeartbeatDataExternal$Outbound;
+
+/** @internal */
+export const AiHeartbeatData$outboundSchema: z.ZodType<
+  AiHeartbeatData$Outbound,
+  AiHeartbeatData
+> = z.union([
+  z.lazy(() => AiHeartbeatDataAwsBedrock$outboundSchema),
+  z.lazy(() => AiHeartbeatDataGcpVertex$outboundSchema),
+  z.lazy(() => AiHeartbeatDataAzureFoundry$outboundSchema),
+  z.lazy(() => AiHeartbeatDataExternal$outboundSchema),
+]);
+
+export function aiHeartbeatDataToJSON(
+  aiHeartbeatData: AiHeartbeatData,
+): string {
+  return JSON.stringify(AiHeartbeatData$outboundSchema.parse(aiHeartbeatData));
+}

package/src/models/aiheartbeatstatus.ts

@@ -0,0 +1,58 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import {
+  HeartbeatCollectionIssue,
+  HeartbeatCollectionIssue$Outbound,
+  HeartbeatCollectionIssue$outboundSchema,
+} from "./heartbeatcollectionissue.js";
+import {
+  ObservedHealth,
+  ObservedHealth$outboundSchema,
+} from "./observedhealth.js";
+import {
+  ProviderLifecycleState,
+  ProviderLifecycleState$outboundSchema,
+} from "./providerlifecyclestate.js";
+
+export type AiHeartbeatStatus = {
+  collectionIssues: Array<HeartbeatCollectionIssue>;
+  health: ObservedHealth;
+  lifecycle: ProviderLifecycleState;
+  message?: string | null | undefined;
+  partial: boolean;
+  stale: boolean;
+};
+
+/** @internal */
+export type AiHeartbeatStatus$Outbound = {
+  collectionIssues: Array<HeartbeatCollectionIssue$Outbound>;
+  health: string;
+  lifecycle: string;
+  message?: string | null | undefined;
+  partial: boolean;
+  stale: boolean;
+};
+
+/** @internal */
+export const AiHeartbeatStatus$outboundSchema: z.ZodType<
+  AiHeartbeatStatus$Outbound,
+  AiHeartbeatStatus
+> = z.object({
+  collectionIssues: z.array(HeartbeatCollectionIssue$outboundSchema),
+  health: ObservedHealth$outboundSchema,
+  lifecycle: ProviderLifecycleState$outboundSchema,
+  message: z.nullable(z.string()).optional(),
+  partial: z.boolean(),
+  stale: z.boolean(),
+});
+
+export function aiHeartbeatStatusToJSON(
+  aiHeartbeatStatus: AiHeartbeatStatus,
+): string {
+  return JSON.stringify(
+    AiHeartbeatStatus$outboundSchema.parse(aiHeartbeatStatus),
+  );
+}

package/src/models/computepoolselection.ts

@@ -3,14 +3,22 @@
  */
 
 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 {
+  FailureDomainSelection,
+  FailureDomainSelection$inboundSchema,
+  FailureDomainSelection$Outbound,
+  FailureDomainSelection$outboundSchema,
+} from "./failuredomainselection.js";
 
 /**
  * Autoscaling machine pool.
  */
 export type ComputePoolSelectionAutoscale = {
+  failureDomains?: FailureDomainSelection | null | undefined;
   /**
    * Provider machine type selected for this deployment.
    */
@@ -30,6 +38,7 @@ export type ComputePoolSelectionAutoscale = {
  * Fixed number of machines.
  */
 export type ComputePoolSelectionFixed = {
+  failureDomains?: FailureDomainSelection | null | undefined;
   /**
    * Provider machine type selected for this deployment.
    */
@@ -53,13 +62,19 @@ export const ComputePoolSelectionAutoscale$inboundSchema: z.ZodType<
   ComputePoolSelectionAutoscale,
   unknown
 > = z.object({
+  failure_domains: z.nullable(FailureDomainSelection$inboundSchema).optional(),
   machine: z.nullable(z.string()).optional(),
   max: z.int(),
   min: z.int(),
   mode: z.literal("autoscale"),
+}).transform((v) => {
+  return remap$(v, {
+    "failure_domains": "failureDomains",
+  });
 });
 /** @internal */
 export type ComputePoolSelectionAutoscale$Outbound = {
+  failure_domains?: FailureDomainSelection$Outbound | null | undefined;
   machine?: string | null | undefined;
   max: number;
   min: number;
@@ -71,10 +86,15 @@ export const ComputePoolSelectionAutoscale$outboundSchema: z.ZodType<
   ComputePoolSelectionAutoscale$Outbound,
   ComputePoolSelectionAutoscale
 > = z.object({
+  failureDomains: z.nullable(FailureDomainSelection$outboundSchema).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 computePoolSelectionAutoscaleToJSON(
@@ -101,12 +121,18 @@ export const ComputePoolSelectionFixed$inboundSchema: z.ZodType<
   ComputePoolSelectionFixed,
   unknown
 > = z.object({
+  failure_domains: z.nullable(FailureDomainSelection$inboundSchema).optional(),
   machine: z.nullable(z.string()).optional(),
   machines: z.int(),
   mode: z.literal("fixed"),
+}).transform((v) => {
+  return remap$(v, {
+    "failure_domains": "failureDomains",
+  });
 });
 /** @internal */
 export type ComputePoolSelectionFixed$Outbound = {
+  failure_domains?: FailureDomainSelection$Outbound | null | undefined;
   machine?: string | null | undefined;
   machines: number;
   mode: "fixed";
@@ -117,9 +143,14 @@ export const ComputePoolSelectionFixed$outboundSchema: z.ZodType<
   ComputePoolSelectionFixed$Outbound,
   ComputePoolSelectionFixed
 > = z.object({
+  failureDomains: z.nullable(FailureDomainSelection$outboundSchema).optional(),
   machine: z.nullable(z.string()).optional(),
   machines: z.int(),
   mode: z.literal("fixed"),
+}).transform((v) => {
+  return remap$(v, {
+    failureDomains: "failure_domains",
+  });
 });
 
 export function computePoolSelectionFixedToJSON(

package/src/models/errors/alienerror.ts

@@ -0,0 +1,213 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import { AlienManagerError } from "./alienmanagererror.js";
+
+/**
+ * Canonical error container that provides a structured way to represent errors
+ *
+ * @remarks
+ * with rich metadata including error codes, human-readable messages, context,
+ * and chaining capabilities for error propagation.
+ *
+ * This struct is designed to be both machine-readable and user-friendly,
+ * supporting serialization for API responses and detailed error reporting
+ * in distributed systems.
+ */
+export type AlienErrorData = {
+  /**
+   * A unique identifier for the type of error.
+   *
+   * @remarks
+   *
+   * This should be a short, machine-readable string that can be used
+   * by clients to programmatically handle different error types.
+   * Examples: "NOT_FOUND", "VALIDATION_ERROR", "TIMEOUT"
+   */
+  code: string;
+  /**
+   * Additional diagnostic information about the error context.
+   *
+   * @remarks
+   *
+   * This optional field can contain structured data providing more details
+   * about the error, such as validation errors, request parameters that
+   * caused the issue, or other relevant context information.
+   */
+  context?: any | undefined;
+  /**
+   * Optional human-facing remediation hint.
+   */
+  hint?: string | null | undefined;
+  /**
+   * HTTP status code for this error.
+   *
+   * @remarks
+   *
+   * Used when converting the error to an HTTP response. If None, falls back to
+   * the error type's default status code or 500.
+   */
+  httpStatusCode?: number | null | undefined;
+  /**
+   * Indicates if this is an internal error that should not be exposed to users.
+   *
+   * @remarks
+   *
+   * When `true`, this error contains sensitive information or implementation
+   * details that should not be shown to end-users. Such errors should be
+   * logged for debugging but replaced with generic error messages in responses.
+   */
+  internal: boolean;
+  /**
+   * Human-readable error message.
+   *
+   * @remarks
+   *
+   * This message should be clear and actionable for developers or end-users,
+   * providing context about what went wrong and potentially how to fix it.
+   */
+  message: string;
+  /**
+   * Indicates whether the operation that caused the error should be retried.
+   *
+   * @remarks
+   *
+   * When `true`, the error is transient and the operation might succeed
+   * if attempted again. When `false`, retrying the same operation is
+   * unlikely to succeed without changes.
+   */
+  retryable?: boolean | undefined;
+  /**
+   * The underlying error that caused this error, creating an error chain.
+   *
+   * @remarks
+   *
+   * This allows for proper error propagation and debugging by maintaining
+   * the full context of how an error occurred through multiple layers
+   * of an application.
+   */
+  source?: any | undefined;
+};
+
+/**
+ * Canonical error container that provides a structured way to represent errors
+ *
+ * @remarks
+ * with rich metadata including error codes, human-readable messages, context,
+ * and chaining capabilities for error propagation.
+ *
+ * This struct is designed to be both machine-readable and user-friendly,
+ * supporting serialization for API responses and detailed error reporting
+ * in distributed systems.
+ */
+export class AlienError extends AlienManagerError {
+  /**
+   * A unique identifier for the type of error.
+   *
+   * @remarks
+   *
+   * This should be a short, machine-readable string that can be used
+   * by clients to programmatically handle different error types.
+   * Examples: "NOT_FOUND", "VALIDATION_ERROR", "TIMEOUT"
+   */
+  code: string;
+  /**
+   * Additional diagnostic information about the error context.
+   *
+   * @remarks
+   *
+   * This optional field can contain structured data providing more details
+   * about the error, such as validation errors, request parameters that
+   * caused the issue, or other relevant context information.
+   */
+  context?: any | undefined;
+  /**
+   * Optional human-facing remediation hint.
+   */
+  hint?: string | null | undefined;
+  /**
+   * HTTP status code for this error.
+   *
+   * @remarks
+   *
+   * Used when converting the error to an HTTP response. If None, falls back to
+   * the error type's default status code or 500.
+   */
+  httpStatusCode?: number | null | undefined;
+  /**
+   * Indicates if this is an internal error that should not be exposed to users.
+   *
+   * @remarks
+   *
+   * When `true`, this error contains sensitive information or implementation
+   * details that should not be shown to end-users. Such errors should be
+   * logged for debugging but replaced with generic error messages in responses.
+   */
+  internal: boolean;
+  /**
+   * Indicates whether the operation that caused the error should be retried.
+   *
+   * @remarks
+   *
+   * When `true`, the error is transient and the operation might succeed
+   * if attempted again. When `false`, retrying the same operation is
+   * unlikely to succeed without changes.
+   */
+  retryable?: boolean | undefined;
+  /**
+   * The underlying error that caused this error, creating an error chain.
+   *
+   * @remarks
+   *
+   * This allows for proper error propagation and debugging by maintaining
+   * the full context of how an error occurred through multiple layers
+   * of an application.
+   */
+  source?: any | undefined;
+
+  /** The original data that was passed to this error instance. */
+  data$: AlienErrorData;
+
+  constructor(
+    err: AlienErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.message || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    this.code = err.code;
+    if (err.context != null) this.context = err.context;
+    if (err.hint != null) this.hint = err.hint;
+    if (err.httpStatusCode != null) this.httpStatusCode = err.httpStatusCode;
+    this.internal = err.internal;
+    if (err.retryable != null) this.retryable = err.retryable;
+    if (err.source != null) this.source = err.source;
+
+    this.name = "AlienError";
+  }
+}
+
+/** @internal */
+export const AlienError$inboundSchema: z.ZodType<AlienError, unknown> = z
+  .object({
+    code: z.string(),
+    context: z.any().optional(),
+    hint: z.nullable(z.string()).optional(),
+    httpStatusCode: z.nullable(z.int()).optional(),
+    internal: z.boolean(),
+    message: z.string(),
+    retryable: z.boolean().default(false),
+    source: z.any().optional(),
+    request$: z.custom<Request>(x => x instanceof Request),
+    response$: z.custom<Response>(x => x instanceof Response),
+    body$: z.string(),
+  })
+  .transform((v) => {
+    return new AlienError(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  });

package/src/models/errors/index.ts

@@ -2,6 +2,7 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
+export * from "./alienerror.js";
 export * from "./alienmanagerdefaulterror.js";
 export * from "./alienmanagererror.js";
 export * from "./errorresponse.js";

package/src/models/exposeprotocol.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";
+
+/**
+ * Protocol for public workload endpoints.
+ */
+export const ExposeProtocol = {
+  Http: "http",
+  Tcp: "tcp",
+} as const;
+/**
+ * Protocol for public workload endpoints.
+ */
+export type ExposeProtocol = ClosedEnum<typeof ExposeProtocol>;
+
+/** @internal */
+export const ExposeProtocol$inboundSchema: z.ZodEnum<typeof ExposeProtocol> = z
+  .enum(ExposeProtocol);