@alienplatform/platform-api 1.0.68 → 1.3.4

package/src/models/package.ts

@@ -2,11 +2,11 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
-import * as z from "zod/v4"
-import { safeParse } from "../lib/schemas.js"
-import type { ClosedEnum } from "../types/enums.js"
-import type { Result as SafeParseResult } from "../types/fp.js"
-import type { SDKValidationError } from "./errors/sdkvalidationerror.js"
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
 /**
  * Types of packages that can be built
@@ -15,13 +15,13 @@ export const PackageTypeEnum = {
   Cli: "cli",
   Cloudformation: "cloudformation",
   Helm: "helm",
-  OperatorImage: "operator-image",
+  AgentImage: "agent-image",
   Terraform: "terraform",
-} as const
+} as const;
 /**
  * Types of packages that can be built
  */
-export type PackageTypeEnum = ClosedEnum<typeof PackageTypeEnum>
+export type PackageTypeEnum = ClosedEnum<typeof PackageTypeEnum>;
 
 /**
  * Status of a package build
@@ -32,11 +32,11 @@ export const PackageStatus = {
   Ready: "ready",
   Failed: "failed",
   Canceled: "canceled",
-} as const
+} as const;
 /**
  * Status of a package build
  */
-export type PackageStatus = ClosedEnum<typeof PackageStatus>
+export type PackageStatus = ClosedEnum<typeof PackageStatus>;
 
 /**
  * Configuration for the Terraform provider binary
@@ -45,28 +45,28 @@ export type ConfigTerraform = {
   /**
    * Terraform provider name (e.g., "acme")
    */
-  providerName: string
+  providerName: string;
   /**
    * Terraform resource type name (e.g., "agent")
    */
-  resourceType: string
-  type: "terraform"
-}
+  resourceType: string;
+  type: "terraform";
+};
 
 /**
- * Configuration for the Operator binary
+ * Branding configuration for the agent binary (white-labeling)
  */
-export type ConfigOperatorImage = {
+export type ConfigAgentImage = {
   /**
    * Human-friendly display name for logs and startup messages
    */
-  displayName: string
+  displayName: string;
   /**
-   * Binary name (e.g., "acme-operator")
+   * Binary name (e.g., "acme-agent")
    */
-  name: string
-  type: "operator-image"
-}
+  name: string;
+  type: "agent-image";
+};
 
 /**
  * Configuration for the Helm chart package
@@ -75,35 +75,35 @@ export type ConfigHelm = {
   /**
    * Chart name (e.g., "acme-operator")
    */
-  chartName: string
+  chartName: string;
   /**
    * Human-friendly description of the chart
    */
-  description: string
-  type: "helm"
-}
+  description: string;
+  type: "helm";
+};
 
 /**
  * Configuration for CloudFormation packages
  */
 export type ConfigCloudformation = {
-  type: "cloudformation"
-}
+  type: "cloudformation";
+};
 
 /**
- * Configuration for the project CLI binary
+ * Branding configuration for the deploy CLI binary (white-labeling)
  */
 export type ConfigCli = {
   /**
    * Human-friendly display name for help banners and about text
    */
-  displayName: string
+  displayName: string;
   /**
-   * Binary name displayed in help and usage (e.g., "my-cli")
+   * Binary name displayed in help and usage (e.g., "acme-deploy")
    */
-  name: string
-  type: "cli"
-}
+  name: string;
+  type: "cli";
+};
 
 /**
  * Type-specific configuration
@@ -112,8 +112,8 @@ export type Config =
   | ConfigCli
   | ConfigCloudformation
   | ConfigHelm
-  | ConfigOperatorImage
-  | ConfigTerraform
+  | ConfigAgentImage
+  | ConfigTerraform;
 
 /**
  * GPG public key for Terraform provider signature verification
@@ -122,12 +122,12 @@ export type PackageGpgPublicKey = {
   /**
    * ASCII-armored public key
    */
-  asciiArmor: string
+  asciiArmor: string;
   /**
    * GPG key ID
    */
-  keyId: string
-}
+  keyId: string;
+};
 
 /**
  * Information about a single Terraform provider package for a specific platform
@@ -136,33 +136,33 @@ export type PackagePlatforms = {
   /**
    * Download URL for the provider zip
    */
-  downloadUrl: string
+  downloadUrl: string;
   /**
    * Filename of the provider zip
    */
-  filename: string
+  filename: string;
   /**
    * SHA256 checksum of the zip file
    */
-  shasum: string
+  shasum: string;
   /**
    * URL to the shasums signature file
    */
-  shasumsSignatureUrl: string
+  shasumsSignatureUrl: string;
   /**
    * URL to the shasums file
    */
-  shasumsUrl: string
+  shasumsUrl: string;
   /**
    * Size of the zip file in bytes
    */
-  size: number
-}
+  size: number;
+};
 
 export const OutputsTypeTerraform = {
   Terraform: "terraform",
-} as const
-export type OutputsTypeTerraform = ClosedEnum<typeof OutputsTypeTerraform>
+} as const;
+export type OutputsTypeTerraform = ClosedEnum<typeof OutputsTypeTerraform>;
 
 /**
  * Outputs from a Terraform provider package build
@@ -171,18 +171,20 @@ export type OutputsTerraform = {
   /**
    * GPG public key for Terraform provider signature verification
    */
-  gpgPublicKey: PackageGpgPublicKey
+  gpgPublicKey: PackageGpgPublicKey;
   /**
    * Provider packages for each target platform
    */
-  platforms: { [k: string]: PackagePlatforms }
-  type: OutputsTypeTerraform
-}
+  platforms: { [k: string]: PackagePlatforms };
+  type: OutputsTypeTerraform;
+};
 
 export const OutputsTypeCloudformation = {
   Cloudformation: "cloudformation",
-} as const
-export type OutputsTypeCloudformation = ClosedEnum<typeof OutputsTypeCloudformation>
+} as const;
+export type OutputsTypeCloudformation = ClosedEnum<
+  typeof OutputsTypeCloudformation
+>;
 
 /**
  * Outputs from a CloudFormation package build
@@ -191,26 +193,26 @@ export type OutputsCloudformation = {
   /**
    * AWS Console quick-launch URL
    */
-  launchStackUrl: string
+  launchStackUrl: string;
   /**
    * SHA256 checksum of the template
    */
-  sha256: string
+  sha256: string;
   /**
    * Template size in bytes
    */
-  size: number
+  size: number;
   /**
    * S3 URL to the CloudFormation template
    */
-  templateUrl: string
-  type: OutputsTypeCloudformation
-}
+  templateUrl: string;
+  type: OutputsTypeCloudformation;
+};
 
 export const OutputsTypeHelm = {
   Helm: "helm",
-} as const
-export type OutputsTypeHelm = ClosedEnum<typeof OutputsTypeHelm>
+} as const;
+export type OutputsTypeHelm = ClosedEnum<typeof OutputsTypeHelm>;
 
 /**
  * Outputs from a Helm chart package build
@@ -219,33 +221,33 @@ export type OutputsHelm = {
   /**
    * OCI chart reference (e.g., "oci://public.ecr.aws/acme/charts/project-id")
    */
-  chart: string
+  chart: string;
   /**
    * Chart version (e.g., "1.2.3")
    */
-  version: string
-  type: OutputsTypeHelm
-}
+  version: string;
+  type: OutputsTypeHelm;
+};
 
-export const OutputsTypeOperatorImage = {
-  OperatorImage: "operator-image",
-} as const
-export type OutputsTypeOperatorImage = ClosedEnum<typeof OutputsTypeOperatorImage>
+export const OutputsTypeAgentImage = {
+  AgentImage: "agent-image",
+} as const;
+export type OutputsTypeAgentImage = ClosedEnum<typeof OutputsTypeAgentImage>;
 
 /**
- * Outputs from an operator image package build
+ * Outputs from an agent image package build
  */
-export type OutputsOperatorImage = {
+export type OutputsAgentImage = {
   /**
    * Image digest (e.g., "sha256:abc123...")
    */
-  digest: string
+  digest: string;
   /**
-   * Full image reference (e.g., "public.ecr.aws/acme/operators/project-id:1.2.3")
+   * Full image reference (e.g., "public.ecr.aws/acme/agents/project-id:1.2.3")
    */
-  image: string
-  type: OutputsTypeOperatorImage
-}
+  image: string;
+  type: OutputsTypeAgentImage;
+};
 
 /**
  * Information about a single binary artifact
@@ -254,21 +256,21 @@ export type PackageBinaries = {
   /**
    * SHA256 checksum
    */
-  sha256: string
+  sha256: string;
   /**
    * File size in bytes
    */
-  size: number
+  size: number;
   /**
    * Download URL for the binary
    */
-  url: string
-}
+  url: string;
+};
 
 export const OutputsTypeCli = {
   Cli: "cli",
-} as const
-export type OutputsTypeCli = ClosedEnum<typeof OutputsTypeCli>
+} as const;
+export type OutputsTypeCli = ClosedEnum<typeof OutputsTypeCli>;
 
 /**
  * Outputs from a CLI package build
@@ -277,153 +279,168 @@ export type OutputsCli = {
   /**
    * Binary information for each target platform
    */
-  binaries: { [k: string]: PackageBinaries }
-  type: OutputsTypeCli
-}
+  binaries: { [k: string]: PackageBinaries };
+  type: OutputsTypeCli;
+};
 
 /**
  * Package outputs (only when status is 'ready')
  */
-export type Outputs =
+export type PackageOutputsUnion =
   | OutputsCloudformation
-  | OutputsOperatorImage
+  | OutputsAgentImage
   | OutputsHelm
   | OutputsTerraform
   | OutputsCli
-  | any
+  | any;
 
 export type Package = {
   /**
    * Unique identifier for the package.
    */
-  id: string
+  id: string;
   /**
    * Unique identifier for the project.
    */
-  projectId: string
+  projectId: string;
   /**
    * Unique identifier for the workspace.
    */
-  workspaceId: string
+  workspaceId: string;
   /**
    * Types of packages that can be built
    */
-  type: PackageTypeEnum
+  type: PackageTypeEnum;
   /**
    * Status of a package build
    */
-  status: PackageStatus
+  status: PackageStatus;
   /**
    * Package version (e.g., '1.0.0', 'rel_abc123')
    */
-  version: string
+  version: string;
   /**
    * Type-specific configuration
    */
-  config: ConfigCli | ConfigCloudformation | ConfigHelm | ConfigOperatorImage | ConfigTerraform
+  config:
+    | ConfigCli
+    | ConfigCloudformation
+    | ConfigHelm
+    | ConfigAgentImage
+    | ConfigTerraform;
   /**
    * Package outputs (only when status is 'ready')
    */
   outputs?:
     | OutputsCloudformation
-    | OutputsOperatorImage
+    | OutputsAgentImage
     | OutputsHelm
     | OutputsTerraform
     | OutputsCli
     | any
     | null
-    | undefined
+    | undefined;
   /**
    * Error information if status is 'failed'
    */
-  error?: any | null | undefined
+  error?: any | null | undefined;
   /**
    * Source binary SHA256 (for cli/terraform packages)
    */
-  sourceBinarySha256?: string | null | undefined
+  sourceBinarySha256?: string | null | undefined;
   /**
    * Number of build retries
    */
-  retries: number
-  lockedAt?: Date | null | undefined
-  lockedBy?: string | null | undefined
-  createdAt: Date
-  updatedAt: Date
-  completedAt?: Date | null | undefined
-}
+  retries: number;
+  lockedAt?: Date | null | undefined;
+  lockedBy?: string | null | undefined;
+  createdAt: Date;
+  updatedAt: Date;
+  completedAt?: Date | null | undefined;
+};
 
 /** @internal */
 export const PackageTypeEnum$inboundSchema: z.ZodEnum<typeof PackageTypeEnum> =
-  z.enum(PackageTypeEnum)
+  z.enum(PackageTypeEnum);
 
 /** @internal */
-export const PackageStatus$inboundSchema: z.ZodEnum<typeof PackageStatus> = z.enum(PackageStatus)
+export const PackageStatus$inboundSchema: z.ZodEnum<typeof PackageStatus> = z
+  .enum(PackageStatus);
 
 /** @internal */
-export const ConfigTerraform$inboundSchema: z.ZodType<ConfigTerraform, unknown> = z.object({
+export const ConfigTerraform$inboundSchema: z.ZodType<
+  ConfigTerraform,
+  unknown
+> = z.object({
   providerName: z.string(),
   resourceType: z.string(),
   type: z.literal("terraform"),
-})
+});
 
 export function configTerraformFromJSON(
   jsonString: string,
 ): SafeParseResult<ConfigTerraform, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => ConfigTerraform$inboundSchema.parse(JSON.parse(x)),
+    (x) => ConfigTerraform$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'ConfigTerraform' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const ConfigOperatorImage$inboundSchema: z.ZodType<ConfigOperatorImage, unknown> = z.object({
+export const ConfigAgentImage$inboundSchema: z.ZodType<
+  ConfigAgentImage,
+  unknown
+> = z.object({
   displayName: z.string(),
   name: z.string(),
-  type: z.literal("operator-image"),
-})
+  type: z.literal("agent-image"),
+});
 
-export function configOperatorImageFromJSON(
+export function configAgentImageFromJSON(
   jsonString: string,
-): SafeParseResult<ConfigOperatorImage, SDKValidationError> {
+): SafeParseResult<ConfigAgentImage, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => ConfigOperatorImage$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ConfigOperatorImage' from JSON`,
-  )
+    (x) => ConfigAgentImage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ConfigAgentImage' from JSON`,
+  );
 }
 
 /** @internal */
-export const ConfigHelm$inboundSchema: z.ZodType<ConfigHelm, unknown> = z.object({
-  chartName: z.string(),
-  description: z.string(),
-  type: z.literal("helm"),
-})
+export const ConfigHelm$inboundSchema: z.ZodType<ConfigHelm, unknown> = z
+  .object({
+    chartName: z.string(),
+    description: z.string(),
+    type: z.literal("helm"),
+  });
 
 export function configHelmFromJSON(
   jsonString: string,
 ): SafeParseResult<ConfigHelm, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => ConfigHelm$inboundSchema.parse(JSON.parse(x)),
+    (x) => ConfigHelm$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'ConfigHelm' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const ConfigCloudformation$inboundSchema: z.ZodType<ConfigCloudformation, unknown> =
-  z.object({
-    type: z.literal("cloudformation"),
-  })
+export const ConfigCloudformation$inboundSchema: z.ZodType<
+  ConfigCloudformation,
+  unknown
+> = z.object({
+  type: z.literal("cloudformation"),
+});
 
 export function configCloudformationFromJSON(
   jsonString: string,
 ): SafeParseResult<ConfigCloudformation, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => ConfigCloudformation$inboundSchema.parse(JSON.parse(x)),
+    (x) => ConfigCloudformation$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'ConfigCloudformation' from JSON`,
-  )
+  );
 }
 
 /** @internal */
@@ -431,16 +448,16 @@ export const ConfigCli$inboundSchema: z.ZodType<ConfigCli, unknown> = z.object({
   displayName: z.string(),
   name: z.string(),
   type: z.literal("cli"),
-})
+});
 
 export function configCliFromJSON(
   jsonString: string,
 ): SafeParseResult<ConfigCli, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => ConfigCli$inboundSchema.parse(JSON.parse(x)),
+    (x) => ConfigCli$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'ConfigCli' from JSON`,
-  )
+  );
 }
 
 /** @internal */
@@ -448,200 +465,223 @@ export const Config$inboundSchema: z.ZodType<Config, unknown> = z.union([
   z.lazy(() => ConfigCli$inboundSchema),
   z.lazy(() => ConfigCloudformation$inboundSchema),
   z.lazy(() => ConfigHelm$inboundSchema),
-  z.lazy(() => ConfigOperatorImage$inboundSchema),
+  z.lazy(() => ConfigAgentImage$inboundSchema),
   z.lazy(() => ConfigTerraform$inboundSchema),
-])
+]);
 
-export function configFromJSON(jsonString: string): SafeParseResult<Config, SDKValidationError> {
+export function configFromJSON(
+  jsonString: string,
+): SafeParseResult<Config, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => Config$inboundSchema.parse(JSON.parse(x)),
+    (x) => Config$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'Config' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const PackageGpgPublicKey$inboundSchema: z.ZodType<PackageGpgPublicKey, unknown> = z.object({
+export const PackageGpgPublicKey$inboundSchema: z.ZodType<
+  PackageGpgPublicKey,
+  unknown
+> = z.object({
   asciiArmor: z.string(),
   keyId: z.string(),
-})
+});
 
 export function packageGpgPublicKeyFromJSON(
   jsonString: string,
 ): SafeParseResult<PackageGpgPublicKey, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => PackageGpgPublicKey$inboundSchema.parse(JSON.parse(x)),
+    (x) => PackageGpgPublicKey$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'PackageGpgPublicKey' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const PackagePlatforms$inboundSchema: z.ZodType<PackagePlatforms, unknown> = z.object({
+export const PackagePlatforms$inboundSchema: z.ZodType<
+  PackagePlatforms,
+  unknown
+> = z.object({
   downloadUrl: z.string(),
   filename: z.string(),
   shasum: z.string(),
   shasumsSignatureUrl: z.string(),
   shasumsUrl: z.string(),
   size: z.int(),
-})
+});
 
 export function packagePlatformsFromJSON(
   jsonString: string,
 ): SafeParseResult<PackagePlatforms, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => PackagePlatforms$inboundSchema.parse(JSON.parse(x)),
+    (x) => PackagePlatforms$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'PackagePlatforms' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const OutputsTypeTerraform$inboundSchema: z.ZodEnum<typeof OutputsTypeTerraform> =
-  z.enum(OutputsTypeTerraform)
+export const OutputsTypeTerraform$inboundSchema: z.ZodEnum<
+  typeof OutputsTypeTerraform
+> = z.enum(OutputsTypeTerraform);
 
 /** @internal */
-export const OutputsTerraform$inboundSchema: z.ZodType<OutputsTerraform, unknown> = z.object({
+export const OutputsTerraform$inboundSchema: z.ZodType<
+  OutputsTerraform,
+  unknown
+> = z.object({
   gpgPublicKey: z.lazy(() => PackageGpgPublicKey$inboundSchema),
-  platforms: z.record(
-    z.string(),
-    z.lazy(() => PackagePlatforms$inboundSchema),
-  ),
+  platforms: z.record(z.string(), z.lazy(() => PackagePlatforms$inboundSchema)),
   type: OutputsTypeTerraform$inboundSchema,
-})
+});
 
 export function outputsTerraformFromJSON(
   jsonString: string,
 ): SafeParseResult<OutputsTerraform, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => OutputsTerraform$inboundSchema.parse(JSON.parse(x)),
+    (x) => OutputsTerraform$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'OutputsTerraform' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const OutputsTypeCloudformation$inboundSchema: z.ZodEnum<typeof OutputsTypeCloudformation> =
-  z.enum(OutputsTypeCloudformation)
+export const OutputsTypeCloudformation$inboundSchema: z.ZodEnum<
+  typeof OutputsTypeCloudformation
+> = z.enum(OutputsTypeCloudformation);
 
 /** @internal */
-export const OutputsCloudformation$inboundSchema: z.ZodType<OutputsCloudformation, unknown> =
-  z.object({
-    launchStackUrl: z.string(),
-    sha256: z.string(),
-    size: z.int(),
-    templateUrl: z.string(),
-    type: OutputsTypeCloudformation$inboundSchema,
-  })
+export const OutputsCloudformation$inboundSchema: z.ZodType<
+  OutputsCloudformation,
+  unknown
+> = z.object({
+  launchStackUrl: z.string(),
+  sha256: z.string(),
+  size: z.int(),
+  templateUrl: z.string(),
+  type: OutputsTypeCloudformation$inboundSchema,
+});
 
 export function outputsCloudformationFromJSON(
   jsonString: string,
 ): SafeParseResult<OutputsCloudformation, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => OutputsCloudformation$inboundSchema.parse(JSON.parse(x)),
+    (x) => OutputsCloudformation$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'OutputsCloudformation' from JSON`,
-  )
+  );
 }
 
 /** @internal */
 export const OutputsTypeHelm$inboundSchema: z.ZodEnum<typeof OutputsTypeHelm> =
-  z.enum(OutputsTypeHelm)
+  z.enum(OutputsTypeHelm);
 
 /** @internal */
-export const OutputsHelm$inboundSchema: z.ZodType<OutputsHelm, unknown> = z.object({
-  chart: z.string(),
-  version: z.string(),
-  type: OutputsTypeHelm$inboundSchema,
-})
+export const OutputsHelm$inboundSchema: z.ZodType<OutputsHelm, unknown> = z
+  .object({
+    chart: z.string(),
+    version: z.string(),
+    type: OutputsTypeHelm$inboundSchema,
+  });
 
 export function outputsHelmFromJSON(
   jsonString: string,
 ): SafeParseResult<OutputsHelm, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => OutputsHelm$inboundSchema.parse(JSON.parse(x)),
+    (x) => OutputsHelm$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'OutputsHelm' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const OutputsTypeOperatorImage$inboundSchema: z.ZodEnum<typeof OutputsTypeOperatorImage> =
-  z.enum(OutputsTypeOperatorImage)
+export const OutputsTypeAgentImage$inboundSchema: z.ZodEnum<
+  typeof OutputsTypeAgentImage
+> = z.enum(OutputsTypeAgentImage);
 
 /** @internal */
-export const OutputsOperatorImage$inboundSchema: z.ZodType<OutputsOperatorImage, unknown> =
-  z.object({
-    digest: z.string(),
-    image: z.string(),
-    type: OutputsTypeOperatorImage$inboundSchema,
-  })
-
-export function outputsOperatorImageFromJSON(
+export const OutputsAgentImage$inboundSchema: z.ZodType<
+  OutputsAgentImage,
+  unknown
+> = z.object({
+  digest: z.string(),
+  image: z.string(),
+  type: OutputsTypeAgentImage$inboundSchema,
+});
+
+export function outputsAgentImageFromJSON(
   jsonString: string,
-): SafeParseResult<OutputsOperatorImage, SDKValidationError> {
+): SafeParseResult<OutputsAgentImage, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => OutputsOperatorImage$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'OutputsOperatorImage' from JSON`,
-  )
+    (x) => OutputsAgentImage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OutputsAgentImage' from JSON`,
+  );
 }
 
 /** @internal */
-export const PackageBinaries$inboundSchema: z.ZodType<PackageBinaries, unknown> = z.object({
+export const PackageBinaries$inboundSchema: z.ZodType<
+  PackageBinaries,
+  unknown
+> = z.object({
   sha256: z.string(),
   size: z.int(),
   url: z.string(),
-})
+});
 
 export function packageBinariesFromJSON(
   jsonString: string,
 ): SafeParseResult<PackageBinaries, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => PackageBinaries$inboundSchema.parse(JSON.parse(x)),
+    (x) => PackageBinaries$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'PackageBinaries' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const OutputsTypeCli$inboundSchema: z.ZodEnum<typeof OutputsTypeCli> = z.enum(OutputsTypeCli)
+export const OutputsTypeCli$inboundSchema: z.ZodEnum<typeof OutputsTypeCli> = z
+  .enum(OutputsTypeCli);
 
 /** @internal */
-export const OutputsCli$inboundSchema: z.ZodType<OutputsCli, unknown> = z.object({
-  binaries: z.record(
-    z.string(),
-    z.lazy(() => PackageBinaries$inboundSchema),
-  ),
-  type: OutputsTypeCli$inboundSchema,
-})
+export const OutputsCli$inboundSchema: z.ZodType<OutputsCli, unknown> = z
+  .object({
+    binaries: z.record(z.string(), z.lazy(() => PackageBinaries$inboundSchema)),
+    type: OutputsTypeCli$inboundSchema,
+  });
 
 export function outputsCliFromJSON(
   jsonString: string,
 ): SafeParseResult<OutputsCli, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => OutputsCli$inboundSchema.parse(JSON.parse(x)),
+    (x) => OutputsCli$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'OutputsCli' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const Outputs$inboundSchema: z.ZodType<Outputs, unknown> = z.union([
+export const PackageOutputsUnion$inboundSchema: z.ZodType<
+  PackageOutputsUnion,
+  unknown
+> = z.union([
   z.lazy(() => OutputsCloudformation$inboundSchema),
-  z.lazy(() => OutputsOperatorImage$inboundSchema),
+  z.lazy(() => OutputsAgentImage$inboundSchema),
   z.lazy(() => OutputsHelm$inboundSchema),
   z.lazy(() => OutputsTerraform$inboundSchema),
   z.lazy(() => OutputsCli$inboundSchema),
   z.any(),
-])
+]);
 
-export function outputsFromJSON(jsonString: string): SafeParseResult<Outputs, SDKValidationError> {
+export function packageOutputsUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<PackageOutputsUnion, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => Outputs$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Outputs' from JSON`,
-  )
+    (x) => PackageOutputsUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PackageOutputsUnion' from JSON`,
+  );
 }
 
 /** @internal */
@@ -656,35 +696,39 @@ export const Package$inboundSchema: z.ZodType<Package, unknown> = z.object({
     z.lazy(() => ConfigCli$inboundSchema),
     z.lazy(() => ConfigCloudformation$inboundSchema),
     z.lazy(() => ConfigHelm$inboundSchema),
-    z.lazy(() => ConfigOperatorImage$inboundSchema),
+    z.lazy(() => ConfigAgentImage$inboundSchema),
     z.lazy(() => ConfigTerraform$inboundSchema),
   ]),
-  outputs: z
-    .nullable(
-      z.union([
-        z.lazy(() => OutputsCloudformation$inboundSchema),
-        z.lazy(() => OutputsOperatorImage$inboundSchema),
-        z.lazy(() => OutputsHelm$inboundSchema),
-        z.lazy(() => OutputsTerraform$inboundSchema),
-        z.lazy(() => OutputsCli$inboundSchema),
-        z.any(),
-      ]),
-    )
-    .optional(),
+  outputs: z.nullable(
+    z.union([
+      z.lazy(() => OutputsCloudformation$inboundSchema),
+      z.lazy(() => OutputsAgentImage$inboundSchema),
+      z.lazy(() => OutputsHelm$inboundSchema),
+      z.lazy(() => OutputsTerraform$inboundSchema),
+      z.lazy(() => OutputsCli$inboundSchema),
+      z.any(),
+    ]),
+  ).optional(),
   error: z.nullable(z.any()).optional(),
   sourceBinarySha256: z.nullable(z.string()).optional(),
   retries: z.int(),
-  lockedAt: z.nullable(z.iso.datetime({ offset: true }).transform(v => new Date(v))).optional(),
+  lockedAt: z.nullable(
+    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
+  ).optional(),
   lockedBy: z.nullable(z.string()).optional(),
   createdAt: z.iso.datetime({ offset: true }).transform(v => new Date(v)),
   updatedAt: z.iso.datetime({ offset: true }).transform(v => new Date(v)),
-  completedAt: z.nullable(z.iso.datetime({ offset: true }).transform(v => new Date(v))).optional(),
-})
+  completedAt: z.nullable(
+    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
+  ).optional(),
+});
 
-export function packageFromJSON(jsonString: string): SafeParseResult<Package, SDKValidationError> {
+export function packageFromJSON(
+  jsonString: string,
+): SafeParseResult<Package, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => Package$inboundSchema.parse(JSON.parse(x)),
+    (x) => Package$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'Package' from JSON`,
-  )
+  );
 }