@alienplatform/manager-api 1.3.4

package/src/lib/security.ts

@@ -0,0 +1,264 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as models from "../models/index.js";
+import { env } from "./env.js";
+
+type OAuth2PasswordFlow = {
+  username: string;
+  password: string;
+  clientID?: string | undefined;
+  clientSecret?: string | undefined;
+  tokenURL: string;
+};
+
+export enum SecurityErrorCode {
+  Incomplete = "incomplete",
+  UnrecognisedSecurityType = "unrecognized_security_type",
+}
+
+export class SecurityError extends Error {
+  constructor(
+    public code: SecurityErrorCode,
+    message: string,
+  ) {
+    super(message);
+    this.name = "SecurityError";
+  }
+
+  static incomplete(): SecurityError {
+    return new SecurityError(
+      SecurityErrorCode.Incomplete,
+      "Security requirements not met in order to perform the operation",
+    );
+  }
+  static unrecognizedType(type: string): SecurityError {
+    return new SecurityError(
+      SecurityErrorCode.UnrecognisedSecurityType,
+      `Unrecognised security type: ${type}`,
+    );
+  }
+}
+
+export type SecurityState = {
+  basic: { username?: string | undefined; password?: string | undefined };
+  headers: Record<string, string>;
+  queryParams: Record<string, string>;
+  cookies: Record<string, string>;
+  oauth2: ({ type: "password" } & OAuth2PasswordFlow) | { type: "none" };
+};
+
+type SecurityInputBasic = {
+  type: "http:basic";
+  value:
+    | { username?: string | undefined; password?: string | undefined }
+    | null
+    | undefined;
+};
+
+type SecurityInputBearer = {
+  type: "http:bearer";
+  value: string | null | undefined;
+  fieldName: string;
+};
+
+type SecurityInputAPIKey = {
+  type: "apiKey:header" | "apiKey:query" | "apiKey:cookie";
+  value: string | null | undefined;
+  fieldName: string;
+};
+
+type SecurityInputOIDC = {
+  type: "openIdConnect";
+  value: string | null | undefined;
+  fieldName: string;
+};
+
+type SecurityInputOAuth2 = {
+  type: "oauth2";
+  value: string | null | undefined;
+  fieldName: string;
+};
+
+type SecurityInputOAuth2ClientCredentials = {
+  type: "oauth2:client_credentials";
+  value:
+    | {
+      clientID?: string | undefined;
+      clientSecret?: string | undefined;
+    }
+    | null
+    | string
+    | undefined;
+  fieldName?: string;
+};
+
+type SecurityInputOAuth2PasswordCredentials = {
+  type: "oauth2:password";
+  value:
+    | string
+    | null
+    | undefined;
+  fieldName?: string;
+};
+
+type SecurityInputCustom = {
+  type: "http:custom";
+  value: any | null | undefined;
+  fieldName?: string;
+};
+
+export type SecurityInput =
+  | SecurityInputBasic
+  | SecurityInputBearer
+  | SecurityInputAPIKey
+  | SecurityInputOAuth2
+  | SecurityInputOAuth2ClientCredentials
+  | SecurityInputOAuth2PasswordCredentials
+  | SecurityInputOIDC
+  | SecurityInputCustom;
+
+export function resolveSecurity(
+  ...options: SecurityInput[][]
+): SecurityState | null {
+  const state: SecurityState = {
+    basic: {},
+    headers: {},
+    queryParams: {},
+    cookies: {},
+    oauth2: { type: "none" },
+  };
+
+  const option = options.find((opts) => {
+    return opts.every((o) => {
+      if (o.value == null) {
+        return false;
+      } else if (o.type === "http:basic") {
+        return o.value.username != null || o.value.password != null;
+      } else if (o.type === "http:custom") {
+        return null;
+      } else if (o.type === "oauth2:password") {
+        return (
+          typeof o.value === "string" && !!o.value
+        );
+      } else if (o.type === "oauth2:client_credentials") {
+        if (typeof o.value == "string") {
+          return !!o.value;
+        }
+        return o.value.clientID != null || o.value.clientSecret != null;
+      } else if (typeof o.value === "string") {
+        return !!o.value;
+      } else {
+        throw new Error(
+          `Unrecognized security type: ${o.type} (value type: ${typeof o
+            .value})`,
+        );
+      }
+    });
+  });
+  if (option == null) {
+    return null;
+  }
+
+  option.forEach((spec) => {
+    if (spec.value == null) {
+      return;
+    }
+
+    const { type } = spec;
+
+    switch (type) {
+      case "apiKey:header":
+        state.headers[spec.fieldName] = spec.value;
+        break;
+      case "apiKey:query":
+        state.queryParams[spec.fieldName] = spec.value;
+        break;
+      case "apiKey:cookie":
+        state.cookies[spec.fieldName] = spec.value;
+        break;
+      case "http:basic":
+        applyBasic(state, spec);
+        break;
+      case "http:custom":
+        break;
+      case "http:bearer":
+        applyBearer(state, spec);
+        break;
+      case "oauth2":
+        applyBearer(state, spec);
+        break;
+      case "oauth2:password":
+        applyBearer(state, spec);
+        break;
+      case "oauth2:client_credentials":
+        break;
+      case "openIdConnect":
+        applyBearer(state, spec);
+        break;
+      default:
+        spec satisfies never;
+        throw SecurityError.unrecognizedType(type);
+    }
+  });
+
+  return state;
+}
+
+function applyBasic(
+  state: SecurityState,
+  spec: SecurityInputBasic,
+) {
+  if (spec.value == null) {
+    return;
+  }
+
+  state.basic = spec.value;
+}
+
+function applyBearer(
+  state: SecurityState,
+  spec:
+    | SecurityInputBearer
+    | SecurityInputOAuth2
+    | SecurityInputOIDC
+    | SecurityInputOAuth2PasswordCredentials,
+) {
+  if (typeof spec.value !== "string" || !spec.value) {
+    return;
+  }
+
+  let value = spec.value;
+  if (value.slice(0, 7).toLowerCase() !== "bearer ") {
+    value = `Bearer ${value}`;
+  }
+
+  if (spec.fieldName !== undefined) {
+    state.headers[spec.fieldName] = value;
+  }
+}
+
+export function resolveGlobalSecurity(
+  security: Partial<models.Security> | null | undefined,
+): SecurityState | null {
+  return resolveSecurity(
+    [
+      {
+        fieldName: "Authorization",
+        type: "apiKey:header",
+        value: security?.bearer ?? env().ALIEN_MANAGER_BEARER,
+      },
+    ],
+  );
+}
+
+export async function extractSecurity<
+  T extends string | Record<string, unknown>,
+>(sec: T | (() => Promise<T>) | undefined): Promise<T | undefined> {
+  if (sec == null) {
+    return;
+  }
+
+  return typeof sec === "function" ? sec() : sec;
+}

package/src/lib/url.ts

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+const hasOwn = Object.prototype.hasOwnProperty;
+
+export type Params = Partial<Record<string, string | number>>;
+
+export function pathToFunc(
+  pathPattern: string,
+  options?: { charEncoding?: "percent" | "none" },
+): (params?: Params) => string {
+  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`);
+      }
+
+      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}`;
+    });
+  };
+}

package/src/models/acquireddeploymentresponse.ts

@@ -0,0 +1,30 @@
+/*
+ * 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 AcquiredDeploymentResponse = {
+  deployment: any;
+};
+
+/** @internal */
+export const AcquiredDeploymentResponse$inboundSchema: z.ZodType<
+  AcquiredDeploymentResponse,
+  unknown
+> = z.object({
+  deployment: z.any(),
+});
+
+export function acquiredDeploymentResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<AcquiredDeploymentResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AcquiredDeploymentResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AcquiredDeploymentResponse' from JSON`,
+  );
+}

package/src/models/acquirerequest.ts

@@ -0,0 +1,39 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import { Platform, Platform$outboundSchema } from "./platform.js";
+
+export type AcquireRequest = {
+  deploymentIds?: Array<string> | null | undefined;
+  limit?: number | undefined;
+  platforms?: Array<Platform> | null | undefined;
+  session: string;
+  statuses?: Array<string> | null | undefined;
+};
+
+/** @internal */
+export type AcquireRequest$Outbound = {
+  deploymentIds?: Array<string> | null | undefined;
+  limit?: number | undefined;
+  platforms?: Array<string> | null | undefined;
+  session: string;
+  statuses?: Array<string> | null | undefined;
+};
+
+/** @internal */
+export const AcquireRequest$outboundSchema: z.ZodType<
+  AcquireRequest$Outbound,
+  AcquireRequest
+> = z.object({
+  deploymentIds: z.nullable(z.array(z.string())).optional(),
+  limit: z.int().optional(),
+  platforms: z.nullable(z.array(Platform$outboundSchema)).optional(),
+  session: z.string(),
+  statuses: z.nullable(z.array(z.string())).optional(),
+});
+
+export function acquireRequestToJSON(acquireRequest: AcquireRequest): string {
+  return JSON.stringify(AcquireRequest$outboundSchema.parse(acquireRequest));
+}

package/src/models/acquireresponse.ts

@@ -0,0 +1,34 @@
+/*
+ * 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 {
+  AcquiredDeploymentResponse,
+  AcquiredDeploymentResponse$inboundSchema,
+} from "./acquireddeploymentresponse.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export type AcquireResponse = {
+  deployments: Array<AcquiredDeploymentResponse>;
+};
+
+/** @internal */
+export const AcquireResponse$inboundSchema: z.ZodType<
+  AcquireResponse,
+  unknown
+> = z.object({
+  deployments: z.array(AcquiredDeploymentResponse$inboundSchema),
+});
+
+export function acquireResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<AcquireResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AcquireResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AcquireResponse' from JSON`,
+  );
+}

package/src/models/agentsyncrequest.ts

@@ -0,0 +1,40 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+
+export type AgentSyncRequest = {
+  /**
+   * Current deployment state as reported by the agent.
+   *
+   * @remarks
+   * When present, the manager updates the deployment record to reflect
+   * the agent's progress (status, stack_state, etc.).
+   */
+  currentState?: any | undefined;
+  deploymentId: string;
+};
+
+/** @internal */
+export type AgentSyncRequest$Outbound = {
+  currentState?: any | undefined;
+  deploymentId: string;
+};
+
+/** @internal */
+export const AgentSyncRequest$outboundSchema: z.ZodType<
+  AgentSyncRequest$Outbound,
+  AgentSyncRequest
+> = z.object({
+  currentState: z.any().optional(),
+  deploymentId: z.string(),
+});
+
+export function agentSyncRequestToJSON(
+  agentSyncRequest: AgentSyncRequest,
+): string {
+  return JSON.stringify(
+    AgentSyncRequest$outboundSchema.parse(agentSyncRequest),
+  );
+}

package/src/models/agentsyncresponse.ts

@@ -0,0 +1,38 @@
+/*
+ * 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 AgentSyncResponse = {
+  /**
+   * Public URL for the commands API. Cloud-deployed functions use this
+   *
+   * @remarks
+   * to poll for pending commands instead of the agent's local sync URL.
+   */
+  commandsUrl?: string | null | undefined;
+  target?: any | undefined;
+};
+
+/** @internal */
+export const AgentSyncResponse$inboundSchema: z.ZodType<
+  AgentSyncResponse,
+  unknown
+> = z.object({
+  commandsUrl: z.nullable(z.string()).optional(),
+  target: z.any().optional(),
+});
+
+export function agentSyncResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<AgentSyncResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AgentSyncResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AgentSyncResponse' from JSON`,
+  );
+}

package/src/models/awscustomcertificateconfig.ts

@@ -0,0 +1,30 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+
+export type AwsCustomCertificateConfig = {
+  certificateArn: string;
+};
+
+/** @internal */
+export type AwsCustomCertificateConfig$Outbound = {
+  certificateArn: string;
+};
+
+/** @internal */
+export const AwsCustomCertificateConfig$outboundSchema: z.ZodType<
+  AwsCustomCertificateConfig$Outbound,
+  AwsCustomCertificateConfig
+> = z.object({
+  certificateArn: z.string(),
+});
+
+export function awsCustomCertificateConfigToJSON(
+  awsCustomCertificateConfig: AwsCustomCertificateConfig,
+): string {
+  return JSON.stringify(
+    AwsCustomCertificateConfig$outboundSchema.parse(awsCustomCertificateConfig),
+  );
+}

package/src/models/azurecustomcertificateconfig.ts

@@ -0,0 +1,32 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+
+export type AzureCustomCertificateConfig = {
+  keyVaultCertificateId: string;
+};
+
+/** @internal */
+export type AzureCustomCertificateConfig$Outbound = {
+  keyVaultCertificateId: string;
+};
+
+/** @internal */
+export const AzureCustomCertificateConfig$outboundSchema: z.ZodType<
+  AzureCustomCertificateConfig$Outbound,
+  AzureCustomCertificateConfig
+> = z.object({
+  keyVaultCertificateId: z.string(),
+});
+
+export function azureCustomCertificateConfigToJSON(
+  azureCustomCertificateConfig: AzureCustomCertificateConfig,
+): string {
+  return JSON.stringify(
+    AzureCustomCertificateConfig$outboundSchema.parse(
+      azureCustomCertificateConfig,
+    ),
+  );
+}

package/src/models/bodyspec.ts

@@ -0,0 +1,151 @@
+/*
+ * 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 {
+  PresignedRequest,
+  PresignedRequest$inboundSchema,
+  PresignedRequest$Outbound,
+  PresignedRequest$outboundSchema,
+} from "./presignedrequest.js";
+
+/**
+ * Storage-backed body
+ */
+export type BodySpecStorage = {
+  mode: "storage";
+  /**
+   * Size of the body in bytes
+   */
+  size?: number | null | undefined;
+  storageGetRequest?: PresignedRequest | null | undefined;
+  /**
+   * Indicates storage upload was used for response submission
+   */
+  storagePutUsed?: boolean | null | undefined;
+};
+
+/**
+ * Inline base64-encoded body
+ */
+export type BodySpecInline = {
+  inlineBase64: string;
+  mode: "inline";
+};
+
+/**
+ * Body specification supporting inline and storage modes
+ */
+export type BodySpec = BodySpecInline | BodySpecStorage;
+
+/** @internal */
+export const BodySpecStorage$inboundSchema: z.ZodType<
+  BodySpecStorage,
+  unknown
+> = z.object({
+  mode: z.literal("storage"),
+  size: z.nullable(z.int()).optional(),
+  storageGetRequest: z.nullable(PresignedRequest$inboundSchema).optional(),
+  storagePutUsed: z.nullable(z.boolean()).optional(),
+});
+/** @internal */
+export type BodySpecStorage$Outbound = {
+  mode: "storage";
+  size?: number | null | undefined;
+  storageGetRequest?: PresignedRequest$Outbound | null | undefined;
+  storagePutUsed?: boolean | null | undefined;
+};
+
+/** @internal */
+export const BodySpecStorage$outboundSchema: z.ZodType<
+  BodySpecStorage$Outbound,
+  BodySpecStorage
+> = z.object({
+  mode: z.literal("storage"),
+  size: z.nullable(z.int()).optional(),
+  storageGetRequest: z.nullable(PresignedRequest$outboundSchema).optional(),
+  storagePutUsed: z.nullable(z.boolean()).optional(),
+});
+
+export function bodySpecStorageToJSON(
+  bodySpecStorage: BodySpecStorage,
+): string {
+  return JSON.stringify(BodySpecStorage$outboundSchema.parse(bodySpecStorage));
+}
+export function bodySpecStorageFromJSON(
+  jsonString: string,
+): SafeParseResult<BodySpecStorage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BodySpecStorage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BodySpecStorage' from JSON`,
+  );
+}
+
+/** @internal */
+export const BodySpecInline$inboundSchema: z.ZodType<BodySpecInline, unknown> =
+  z.object({
+    inlineBase64: z.string(),
+    mode: z.literal("inline"),
+  });
+/** @internal */
+export type BodySpecInline$Outbound = {
+  inlineBase64: string;
+  mode: "inline";
+};
+
+/** @internal */
+export const BodySpecInline$outboundSchema: z.ZodType<
+  BodySpecInline$Outbound,
+  BodySpecInline
+> = z.object({
+  inlineBase64: z.string(),
+  mode: z.literal("inline"),
+});
+
+export function bodySpecInlineToJSON(bodySpecInline: BodySpecInline): string {
+  return JSON.stringify(BodySpecInline$outboundSchema.parse(bodySpecInline));
+}
+export function bodySpecInlineFromJSON(
+  jsonString: string,
+): SafeParseResult<BodySpecInline, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BodySpecInline$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BodySpecInline' from JSON`,
+  );
+}
+
+/** @internal */
+export const BodySpec$inboundSchema: z.ZodType<BodySpec, unknown> = z.union([
+  z.lazy(() => BodySpecInline$inboundSchema),
+  z.lazy(() => BodySpecStorage$inboundSchema),
+]);
+/** @internal */
+export type BodySpec$Outbound =
+  | BodySpecInline$Outbound
+  | BodySpecStorage$Outbound;
+
+/** @internal */
+export const BodySpec$outboundSchema: z.ZodType<BodySpec$Outbound, BodySpec> = z
+  .union([
+    z.lazy(() => BodySpecInline$outboundSchema),
+    z.lazy(() => BodySpecStorage$outboundSchema),
+  ]);
+
+export function bodySpecToJSON(bodySpec: BodySpec): string {
+  return JSON.stringify(BodySpec$outboundSchema.parse(bodySpec));
+}
+export function bodySpecFromJSON(
+  jsonString: string,
+): SafeParseResult<BodySpec, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BodySpec$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BodySpec' from JSON`,
+  );
+}