@alienplatform/platform-api 3.3.12 → 3.3.14

package/src/models/observedinventorybatch.ts

@@ -0,0 +1,443 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+
+/**
+ * Backend whose observer produced this snapshot.
+ */
+export const ObservedInventoryBatchBackend = {
+  Aws: "aws",
+  Gcp: "gcp",
+  Azure: "azure",
+  Kubernetes: "kubernetes",
+  Local: "local",
+  Managed: "managed",
+  External: "external",
+  Test: "test",
+} as const;
+/**
+ * Backend whose observer produced this snapshot.
+ */
+export type ObservedInventoryBatchBackend = ClosedEnum<
+  typeof ObservedInventoryBatchBackend
+>;
+
+/**
+ * Represents the target cloud platform.
+ */
+export const ObservedInventoryBatchControllerPlatform = {
+  Aws: "aws",
+  Gcp: "gcp",
+  Azure: "azure",
+  Kubernetes: "kubernetes",
+  Machines: "machines",
+  Local: "local",
+  Test: "test",
+} as const;
+/**
+ * Represents the target cloud platform.
+ */
+export type ObservedInventoryBatchControllerPlatform = ClosedEnum<
+  typeof ObservedInventoryBatchControllerPlatform
+>;
+
+export const ObservedInventoryBatchReason = {
+  Forbidden: "forbidden",
+  NotInstalled: "not-installed",
+  ApiUnavailable: "api-unavailable",
+  CollectionFailed: "collection-failed",
+  TimedOut: "timed-out",
+} as const;
+export type ObservedInventoryBatchReason = ClosedEnum<
+  typeof ObservedInventoryBatchReason
+>;
+
+export const ObservedInventoryBatchSeverity = {
+  Info: "info",
+  Warning: "warning",
+  Error: "error",
+} as const;
+export type ObservedInventoryBatchSeverity = ClosedEnum<
+  typeof ObservedInventoryBatchSeverity
+>;
+
+export type ObservedInventoryBatchCollectionIssue = {
+  message: string;
+  reason: ObservedInventoryBatchReason;
+  severity: ObservedInventoryBatchSeverity;
+  source: string;
+};
+
+export type Counts = {
+  current?: number | null | undefined;
+  desired?: number | null | undefined;
+  ready?: number | null | undefined;
+};
+
+export type CountsUnion = Counts | any;
+
+export const ObservedInventoryBatchHealth = {
+  Unknown: "unknown",
+  Healthy: "healthy",
+  Degraded: "degraded",
+  Unhealthy: "unhealthy",
+} as const;
+export type ObservedInventoryBatchHealth = ClosedEnum<
+  typeof ObservedInventoryBatchHealth
+>;
+
+export const ObservedInventoryBatchLifecycle = {
+  Unknown: "unknown",
+  Creating: "creating",
+  Updating: "updating",
+  Running: "running",
+  Scaling: "scaling",
+  Stopping: "stopping",
+  Stopped: "stopped",
+  Deleting: "deleting",
+  Deleted: "deleted",
+  Failed: "failed",
+} as const;
+export type ObservedInventoryBatchLifecycle = ClosedEnum<
+  typeof ObservedInventoryBatchLifecycle
+>;
+
+export const ObservedInventoryBatchFormat = {
+  Json: "json",
+  Yaml: "yaml",
+  Text: "text",
+} as const;
+export type ObservedInventoryBatchFormat = ClosedEnum<
+  typeof ObservedInventoryBatchFormat
+>;
+
+export type ObservedInventoryBatchRaw = {
+  body: string;
+  collectedAt: Date;
+  format: ObservedInventoryBatchFormat;
+  source: string;
+  truncated: boolean;
+};
+
+export type ResourceTypeHint = string | any;
+
+export type ObservedInventoryBatchResource = {
+  alienResourceId?: string | null | undefined;
+  attributes?: { [k: string]: any | null } | undefined;
+  collectionIssues?: Array<ObservedInventoryBatchCollectionIssue> | undefined;
+  counts?: Counts | any | null | undefined;
+  deploymentId?: string | null | undefined;
+  displayName: string;
+  health: ObservedInventoryBatchHealth;
+  labels?: { [k: string]: string } | undefined;
+  lifecycle: ObservedInventoryBatchLifecycle;
+  message?: string | null | undefined;
+  namespace?: string | null | undefined;
+  partial: boolean;
+  /**
+   * Provider-native kind, such as `apps/v1/Deployment`,
+   *
+   * @remarks
+   * `AWS::S3::Bucket`, `storage.googleapis.com/Bucket`, or an Azure
+   * resource type.
+   */
+  providerKind: string;
+  providerStale: boolean;
+  raw?: Array<ObservedInventoryBatchRaw> | undefined;
+  /**
+   * Provider-native stable identity: Kubernetes object identity, cloud ARN,
+   *
+   * @remarks
+   * GCP full resource name, Azure resource id, etc.
+   */
+  rawIdentity: string;
+  region?: string | null | undefined;
+  resourceTypeHint?: string | any | null | undefined;
+  scope?: string | null | undefined;
+  /**
+   * Release/version identity observed from the provider resource, when available.
+   */
+  version?: string | null | undefined;
+};
+
+export type ObservedInventoryBatch = {
+  /**
+   * Backend whose observer produced this snapshot.
+   */
+  backend: ObservedInventoryBatchBackend;
+  /**
+   * Whether this batch is a complete replacement for the scope. Complete
+   *
+   * @remarks
+   * batches tombstone previously observed rows in the same scope when they
+   * are absent from `resources`.
+   */
+  complete: boolean;
+  /**
+   * Represents the target cloud platform.
+   */
+  controllerPlatform: ObservedInventoryBatchControllerPlatform;
+  /**
+   * Stable scope for the provider list operation that produced this batch.
+   */
+  inventoryScope: string;
+  /**
+   * Time the inventory scope was observed.
+   */
+  observedAt: Date;
+  resources: Array<ObservedInventoryBatchResource>;
+  /**
+   * Writer/source for this inventory pass, such as `operator` or
+   *
+   * @remarks
+   * `manager-observer`.
+   */
+  sourceKind: string;
+};
+
+/** @internal */
+export const ObservedInventoryBatchBackend$outboundSchema: z.ZodEnum<
+  typeof ObservedInventoryBatchBackend
+> = z.enum(ObservedInventoryBatchBackend);
+
+/** @internal */
+export const ObservedInventoryBatchControllerPlatform$outboundSchema: z.ZodEnum<
+  typeof ObservedInventoryBatchControllerPlatform
+> = z.enum(ObservedInventoryBatchControllerPlatform);
+
+/** @internal */
+export const ObservedInventoryBatchReason$outboundSchema: z.ZodEnum<
+  typeof ObservedInventoryBatchReason
+> = z.enum(ObservedInventoryBatchReason);
+
+/** @internal */
+export const ObservedInventoryBatchSeverity$outboundSchema: z.ZodEnum<
+  typeof ObservedInventoryBatchSeverity
+> = z.enum(ObservedInventoryBatchSeverity);
+
+/** @internal */
+export type ObservedInventoryBatchCollectionIssue$Outbound = {
+  message: string;
+  reason: string;
+  severity: string;
+  source: string;
+};
+
+/** @internal */
+export const ObservedInventoryBatchCollectionIssue$outboundSchema: z.ZodType<
+  ObservedInventoryBatchCollectionIssue$Outbound,
+  ObservedInventoryBatchCollectionIssue
+> = z.object({
+  message: z.string(),
+  reason: ObservedInventoryBatchReason$outboundSchema,
+  severity: ObservedInventoryBatchSeverity$outboundSchema,
+  source: z.string(),
+});
+
+export function observedInventoryBatchCollectionIssueToJSON(
+  observedInventoryBatchCollectionIssue: ObservedInventoryBatchCollectionIssue,
+): string {
+  return JSON.stringify(
+    ObservedInventoryBatchCollectionIssue$outboundSchema.parse(
+      observedInventoryBatchCollectionIssue,
+    ),
+  );
+}
+
+/** @internal */
+export type Counts$Outbound = {
+  current?: number | null | undefined;
+  desired?: number | null | undefined;
+  ready?: number | null | undefined;
+};
+
+/** @internal */
+export const Counts$outboundSchema: z.ZodType<Counts$Outbound, Counts> = z
+  .object({
+    current: z.nullable(z.int()).optional(),
+    desired: z.nullable(z.int()).optional(),
+    ready: z.nullable(z.int()).optional(),
+  });
+
+export function countsToJSON(counts: Counts): string {
+  return JSON.stringify(Counts$outboundSchema.parse(counts));
+}
+
+/** @internal */
+export type CountsUnion$Outbound = Counts$Outbound | any;
+
+/** @internal */
+export const CountsUnion$outboundSchema: z.ZodType<
+  CountsUnion$Outbound,
+  CountsUnion
+> = z.union([z.lazy(() => Counts$outboundSchema), z.any()]);
+
+export function countsUnionToJSON(countsUnion: CountsUnion): string {
+  return JSON.stringify(CountsUnion$outboundSchema.parse(countsUnion));
+}
+
+/** @internal */
+export const ObservedInventoryBatchHealth$outboundSchema: z.ZodEnum<
+  typeof ObservedInventoryBatchHealth
+> = z.enum(ObservedInventoryBatchHealth);
+
+/** @internal */
+export const ObservedInventoryBatchLifecycle$outboundSchema: z.ZodEnum<
+  typeof ObservedInventoryBatchLifecycle
+> = z.enum(ObservedInventoryBatchLifecycle);
+
+/** @internal */
+export const ObservedInventoryBatchFormat$outboundSchema: z.ZodEnum<
+  typeof ObservedInventoryBatchFormat
+> = z.enum(ObservedInventoryBatchFormat);
+
+/** @internal */
+export type ObservedInventoryBatchRaw$Outbound = {
+  body: string;
+  collectedAt: string;
+  format: string;
+  source: string;
+  truncated: boolean;
+};
+
+/** @internal */
+export const ObservedInventoryBatchRaw$outboundSchema: z.ZodType<
+  ObservedInventoryBatchRaw$Outbound,
+  ObservedInventoryBatchRaw
+> = z.object({
+  body: z.string(),
+  collectedAt: z.date().transform(v => v.toISOString()),
+  format: ObservedInventoryBatchFormat$outboundSchema,
+  source: z.string(),
+  truncated: z.boolean(),
+});
+
+export function observedInventoryBatchRawToJSON(
+  observedInventoryBatchRaw: ObservedInventoryBatchRaw,
+): string {
+  return JSON.stringify(
+    ObservedInventoryBatchRaw$outboundSchema.parse(observedInventoryBatchRaw),
+  );
+}
+
+/** @internal */
+export type ResourceTypeHint$Outbound = string | any;
+
+/** @internal */
+export const ResourceTypeHint$outboundSchema: z.ZodType<
+  ResourceTypeHint$Outbound,
+  ResourceTypeHint
+> = z.union([z.string(), z.any()]);
+
+export function resourceTypeHintToJSON(
+  resourceTypeHint: ResourceTypeHint,
+): string {
+  return JSON.stringify(
+    ResourceTypeHint$outboundSchema.parse(resourceTypeHint),
+  );
+}
+
+/** @internal */
+export type ObservedInventoryBatchResource$Outbound = {
+  alienResourceId?: string | null | undefined;
+  attributes?: { [k: string]: any | null } | undefined;
+  collectionIssues?:
+    | Array<ObservedInventoryBatchCollectionIssue$Outbound>
+    | undefined;
+  counts?: Counts$Outbound | any | null | undefined;
+  deploymentId?: string | null | undefined;
+  displayName: string;
+  health: string;
+  labels?: { [k: string]: string } | undefined;
+  lifecycle: string;
+  message?: string | null | undefined;
+  namespace?: string | null | undefined;
+  partial: boolean;
+  providerKind: string;
+  providerStale: boolean;
+  raw?: Array<ObservedInventoryBatchRaw$Outbound> | undefined;
+  rawIdentity: string;
+  region?: string | null | undefined;
+  resourceTypeHint?: string | any | null | undefined;
+  scope?: string | null | undefined;
+  version?: string | null | undefined;
+};
+
+/** @internal */
+export const ObservedInventoryBatchResource$outboundSchema: z.ZodType<
+  ObservedInventoryBatchResource$Outbound,
+  ObservedInventoryBatchResource
+> = z.object({
+  alienResourceId: z.nullable(z.string()).optional(),
+  attributes: z.record(z.string(), z.nullable(z.any())).optional(),
+  collectionIssues: z.array(
+    z.lazy(() => ObservedInventoryBatchCollectionIssue$outboundSchema),
+  ).optional(),
+  counts: z.nullable(z.union([z.lazy(() => Counts$outboundSchema), z.any()]))
+    .optional(),
+  deploymentId: z.nullable(z.string()).optional(),
+  displayName: z.string(),
+  health: ObservedInventoryBatchHealth$outboundSchema,
+  labels: z.record(z.string(), z.string()).optional(),
+  lifecycle: ObservedInventoryBatchLifecycle$outboundSchema,
+  message: z.nullable(z.string()).optional(),
+  namespace: z.nullable(z.string()).optional(),
+  partial: z.boolean(),
+  providerKind: z.string(),
+  providerStale: z.boolean(),
+  raw: z.array(z.lazy(() => ObservedInventoryBatchRaw$outboundSchema))
+    .optional(),
+  rawIdentity: z.string(),
+  region: z.nullable(z.string()).optional(),
+  resourceTypeHint: z.nullable(z.union([z.string(), z.any()])).optional(),
+  scope: z.nullable(z.string()).optional(),
+  version: z.nullable(z.string()).optional(),
+});
+
+export function observedInventoryBatchResourceToJSON(
+  observedInventoryBatchResource: ObservedInventoryBatchResource,
+): string {
+  return JSON.stringify(
+    ObservedInventoryBatchResource$outboundSchema.parse(
+      observedInventoryBatchResource,
+    ),
+  );
+}
+
+/** @internal */
+export type ObservedInventoryBatch$Outbound = {
+  backend: string;
+  complete: boolean;
+  controllerPlatform: string;
+  inventoryScope: string;
+  observedAt: string;
+  resources: Array<ObservedInventoryBatchResource$Outbound>;
+  sourceKind: string;
+};
+
+/** @internal */
+export const ObservedInventoryBatch$outboundSchema: z.ZodType<
+  ObservedInventoryBatch$Outbound,
+  ObservedInventoryBatch
+> = z.object({
+  backend: ObservedInventoryBatchBackend$outboundSchema,
+  complete: z.boolean(),
+  controllerPlatform: ObservedInventoryBatchControllerPlatform$outboundSchema,
+  inventoryScope: z.string(),
+  observedAt: z.date().transform(v => v.toISOString()),
+  resources: z.array(
+    z.lazy(() => ObservedInventoryBatchResource$outboundSchema),
+  ),
+  sourceKind: z.string(),
+});
+
+export function observedInventoryBatchToJSON(
+  observedInventoryBatch: ObservedInventoryBatch,
+): string {
+  return JSON.stringify(
+    ObservedInventoryBatch$outboundSchema.parse(observedInventoryBatch),
+  );
+}

package/src/models/operations/acceptworkspaceinvitation.ts

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

package/src/models/operations/applycontainerregistrymanagersnapshot.ts

@@ -0,0 +1,175 @@
+/*
+ * 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 { ClosedEnum } from "../../types/enums.js";
+
+export const ApplyContainerRegistryManagerSnapshotStatus = {
+  Ready: "ready",
+  Deleted: "deleted",
+  Failed: "failed",
+} as const;
+export type ApplyContainerRegistryManagerSnapshotStatus = ClosedEnum<
+  typeof ApplyContainerRegistryManagerSnapshotStatus
+>;
+
+export type ApplyContainerRegistryManagerSnapshotRepository = {
+  /**
+   * Unique identifier for the container registry repository.
+   */
+  id: string;
+  status: ApplyContainerRegistryManagerSnapshotStatus;
+  routableUpstreamName: string | null;
+  error: string | null;
+};
+
+export type Verification = {
+  succeeded: boolean;
+  observedAt: Date;
+  error: string | null;
+};
+
+export type ApplyContainerRegistryManagerSnapshotRequestBody = {
+  /**
+   * Unique identifier for the container registry route.
+   */
+  routeId: string;
+  desiredRevision: number;
+  repositories: Array<ApplyContainerRegistryManagerSnapshotRepository>;
+  verification: Verification | null;
+};
+
+export type ApplyContainerRegistryManagerSnapshotRequest = {
+  id: string;
+  requestBody?: ApplyContainerRegistryManagerSnapshotRequestBody | undefined;
+};
+
+/** @internal */
+export const ApplyContainerRegistryManagerSnapshotStatus$outboundSchema:
+  z.ZodEnum<typeof ApplyContainerRegistryManagerSnapshotStatus> = z.enum(
+    ApplyContainerRegistryManagerSnapshotStatus,
+  );
+
+/** @internal */
+export type ApplyContainerRegistryManagerSnapshotRepository$Outbound = {
+  id: string;
+  status: string;
+  routableUpstreamName: string | null;
+  error: string | null;
+};
+
+/** @internal */
+export const ApplyContainerRegistryManagerSnapshotRepository$outboundSchema:
+  z.ZodType<
+    ApplyContainerRegistryManagerSnapshotRepository$Outbound,
+    ApplyContainerRegistryManagerSnapshotRepository
+  > = z.object({
+    id: z.string(),
+    status: ApplyContainerRegistryManagerSnapshotStatus$outboundSchema,
+    routableUpstreamName: z.nullable(z.string()),
+    error: z.nullable(z.string()),
+  });
+
+export function applyContainerRegistryManagerSnapshotRepositoryToJSON(
+  applyContainerRegistryManagerSnapshotRepository:
+    ApplyContainerRegistryManagerSnapshotRepository,
+): string {
+  return JSON.stringify(
+    ApplyContainerRegistryManagerSnapshotRepository$outboundSchema.parse(
+      applyContainerRegistryManagerSnapshotRepository,
+    ),
+  );
+}
+
+/** @internal */
+export type Verification$Outbound = {
+  succeeded: boolean;
+  observedAt: string;
+  error: string | null;
+};
+
+/** @internal */
+export const Verification$outboundSchema: z.ZodType<
+  Verification$Outbound,
+  Verification
+> = z.object({
+  succeeded: z.boolean(),
+  observedAt: z.date().transform(v => v.toISOString()),
+  error: z.nullable(z.string()),
+});
+
+export function verificationToJSON(verification: Verification): string {
+  return JSON.stringify(Verification$outboundSchema.parse(verification));
+}
+
+/** @internal */
+export type ApplyContainerRegistryManagerSnapshotRequestBody$Outbound = {
+  routeId: string;
+  desiredRevision: number;
+  repositories: Array<ApplyContainerRegistryManagerSnapshotRepository$Outbound>;
+  verification: Verification$Outbound | null;
+};
+
+/** @internal */
+export const ApplyContainerRegistryManagerSnapshotRequestBody$outboundSchema:
+  z.ZodType<
+    ApplyContainerRegistryManagerSnapshotRequestBody$Outbound,
+    ApplyContainerRegistryManagerSnapshotRequestBody
+  > = z.object({
+    routeId: z.string(),
+    desiredRevision: z.int(),
+    repositories: z.array(
+      z.lazy(() =>
+        ApplyContainerRegistryManagerSnapshotRepository$outboundSchema
+      ),
+    ),
+    verification: z.nullable(z.lazy(() => Verification$outboundSchema)),
+  });
+
+export function applyContainerRegistryManagerSnapshotRequestBodyToJSON(
+  applyContainerRegistryManagerSnapshotRequestBody:
+    ApplyContainerRegistryManagerSnapshotRequestBody,
+): string {
+  return JSON.stringify(
+    ApplyContainerRegistryManagerSnapshotRequestBody$outboundSchema.parse(
+      applyContainerRegistryManagerSnapshotRequestBody,
+    ),
+  );
+}
+
+/** @internal */
+export type ApplyContainerRegistryManagerSnapshotRequest$Outbound = {
+  id: string;
+  RequestBody?:
+    | ApplyContainerRegistryManagerSnapshotRequestBody$Outbound
+    | undefined;
+};
+
+/** @internal */
+export const ApplyContainerRegistryManagerSnapshotRequest$outboundSchema:
+  z.ZodType<
+    ApplyContainerRegistryManagerSnapshotRequest$Outbound,
+    ApplyContainerRegistryManagerSnapshotRequest
+  > = z.object({
+    id: z.string(),
+    requestBody: z.lazy(() =>
+      ApplyContainerRegistryManagerSnapshotRequestBody$outboundSchema
+    ).optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      requestBody: "RequestBody",
+    });
+  });
+
+export function applyContainerRegistryManagerSnapshotRequestToJSON(
+  applyContainerRegistryManagerSnapshotRequest:
+    ApplyContainerRegistryManagerSnapshotRequest,
+): string {
+  return JSON.stringify(
+    ApplyContainerRegistryManagerSnapshotRequest$outboundSchema.parse(
+      applyContainerRegistryManagerSnapshotRequest,
+    ),
+  );
+}

package/src/models/operations/approveagentsession.ts

@@ -0,0 +1,36 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+
+export type ApproveAgentSessionRequest = {
+  id: string;
+  /**
+   * Workspace name. Required for user/session/OAuth requests. Optional for API keys because API keys are workspace-scoped; if provided with an API key, it must match the key's workspace.
+   */
+  workspace?: string | undefined;
+};
+
+/** @internal */
+export type ApproveAgentSessionRequest$Outbound = {
+  id: string;
+  workspace?: string | undefined;
+};
+
+/** @internal */
+export const ApproveAgentSessionRequest$outboundSchema: z.ZodType<
+  ApproveAgentSessionRequest$Outbound,
+  ApproveAgentSessionRequest
+> = z.object({
+  id: z.string(),
+  workspace: z.string().optional(),
+});
+
+export function approveAgentSessionRequestToJSON(
+  approveAgentSessionRequest: ApproveAgentSessionRequest,
+): string {
+  return JSON.stringify(
+    ApproveAgentSessionRequest$outboundSchema.parse(approveAgentSessionRequest),
+  );
+}