@alienplatform/platform-api 1.0.68 → 1.3.4

package/src/models/event.ts

@@ -2,184 +2,187 @@
  * 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 { collectExtraKeys as collectExtraKeys$, 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 { remap as remap$ } from "../lib/primitives.js";
+import {
+  collectExtraKeys as collectExtraKeys$,
+  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";
 
 export type DataEmptyingBuckets = {
   /**
    * Names of the S3 buckets being emptied
    */
-  bucketNames: Array<string>
-  type: "EmptyingBuckets"
-}
+  bucketNames: Array<string>;
+  type: "EmptyingBuckets";
+};
 
 export type DataDeletingCloudFormationStack = {
   /**
    * Name of the CloudFormation stack
    */
-  cfnStackName: string
+  cfnStackName: string;
   /**
    * Current stack status
    */
-  currentStatus: string
-  type: "DeletingCloudFormationStack"
-}
+  currentStatus: string;
+  type: "DeletingCloudFormationStack";
+};
 
 export type DataImportingStackStateFromCloudFormation = {
   /**
    * Name of the CloudFormation stack
    */
-  cfnStackName: string
-  type: "ImportingStackStateFromCloudFormation"
-}
+  cfnStackName: string;
+  type: "ImportingStackStateFromCloudFormation";
+};
 
 export type DataAssumingRole = {
   /**
    * ARN of the role to assume
    */
-  roleArn: string
-  type: "AssumingRole"
-}
+  roleArn: string;
+  type: "AssumingRole";
+};
 
 export type DataDeployingCloudFormationStack = {
   /**
    * Name of the CloudFormation stack
    */
-  cfnStackName: string
+  cfnStackName: string;
   /**
    * Current stack status
    */
-  currentStatus: string
-  type: "DeployingCloudFormationStack"
-}
+  currentStatus: string;
+  type: "DeployingCloudFormationStack";
+};
 
 export type DataEnsuringDockerRepository = {
   /**
    * Name of the docker repository
    */
-  repositoryName: string
-  type: "EnsuringDockerRepository"
-}
+  repositoryName: string;
+  type: "EnsuringDockerRepository";
+};
 
 export type DataSettingUpPlatformContext = {
   /**
    * Name of the platform (e.g., "AWS", "GCP")
    */
-  platformName: string
-  type: "SettingUpPlatformContext"
-}
+  platformName: string;
+  type: "SettingUpPlatformContext";
+};
 
 export type DataCleaningUpEnvironment = {
   /**
    * Name of the stack being cleaned up
    */
-  stackName: string
+  stackName: string;
   /**
    * Name of the deployment strategy being used for cleanup
    */
-  strategyName: string
-  type: "CleaningUpEnvironment"
-}
+  strategyName: string;
+  type: "CleaningUpEnvironment";
+};
 
 export type DataCleaningUpStack = {
   /**
    * Name of the stack being cleaned up
    */
-  stackName: string
+  stackName: string;
   /**
    * Name of the deployment strategy being used for cleanup
    */
-  strategyName: string
-  type: "CleaningUpStack"
-}
+  strategyName: string;
+  type: "CleaningUpStack";
+};
 
 export type DataRunningTestFunction = {
   /**
    * Name of the stack being tested
    */
-  stackName: string
-  type: "RunningTestFunction"
-}
+  stackName: string;
+  type: "RunningTestFunction";
+};
 
 export type DataDeployingStack = {
   /**
    * Name of the stack being deployed
    */
-  stackName: string
-  type: "DeployingStack"
-}
+  stackName: string;
+  type: "DeployingStack";
+};
 
 export type DataPreparingEnvironment = {
   /**
    * Name of the deployment strategy being used
    */
-  strategyName: string
-  type: "PreparingEnvironment"
-}
+  strategyName: string;
+  type: "PreparingEnvironment";
+};
 
 export type DataDebuggingAgent = {
   /**
    * ID of the agent being debugged
    */
-  agentId: string
+  agentId: string;
   /**
    * ID of the debug session
    */
-  debugSessionId: string
-  type: "DebuggingAgent"
-}
+  debugSessionId: string;
+  type: "DebuggingAgent";
+};
 
 export type DataDeletingAgent = {
   /**
    * ID of the agent being deleted
    */
-  agentId: string
+  agentId: string;
   /**
    * ID of the release that was running on the agent
    */
-  releaseId: string
-  type: "DeletingAgent"
-}
+  releaseId: string;
+  type: "DeletingAgent";
+};
 
 export type DataUpdatingAgent = {
   /**
    * ID of the agent being updated
    */
-  agentId: string
+  agentId: string;
   /**
    * ID of the new release being deployed to the agent
    */
-  releaseId: string
-  type: "UpdatingAgent"
-}
+  releaseId: string;
+  type: "UpdatingAgent";
+};
 
 export type DataProvisioningAgent = {
   /**
    * ID of the agent being provisioned
    */
-  agentId: string
+  agentId: string;
   /**
    * ID of the release being deployed to the agent
    */
-  releaseId: string
-  type: "ProvisioningAgent"
-}
+  releaseId: string;
+  type: "ProvisioningAgent";
+};
 
 export type DataGeneratingTemplate = {
   /**
    * Platform for which the template is being generated
    */
-  platform: string
-  type: "GeneratingTemplate"
-}
+  platform: string;
+  type: "GeneratingTemplate";
+};
 
 export type DataGeneratingCloudFormationTemplate = {
-  type: "GeneratingCloudFormationTemplate"
-}
+  type: "GeneratingCloudFormationTemplate";
+};
 
 /**
  * Represents the target cloud platform.
@@ -191,11 +194,11 @@ export const EventPlatform = {
   Kubernetes: "kubernetes",
   Local: "local",
   Test: "test",
-} as const
+} as const;
 /**
  * Represents the target cloud platform.
  */
-export type EventPlatform = ClosedEnum<typeof EventPlatform>
+export type EventPlatform = ClosedEnum<typeof EventPlatform>;
 
 /**
  * Resource that can hold any resource type in the Alien system. All resources share common 'type' and 'id' fields with additional type-specific properties.
@@ -204,13 +207,13 @@ export type EventConfig = {
   /**
    * The unique identifier for this specific resource instance. Must contain only alphanumeric characters, hyphens, and underscores ([A-Za-z0-9-_]). Maximum 64 characters.
    */
-  id: string
+  id: string;
   /**
    * Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.
    */
-  type: string
-  additionalProperties?: { [k: string]: any | null } | undefined
-}
+  type: string;
+  additionalProperties?: { [k: string]: any | null } | undefined;
+};
 
 /**
  * New ResourceRef that works with any resource type.
@@ -219,12 +222,12 @@ export type EventConfig = {
  * This can eventually replace the enum-based ResourceRef for full extensibility.
  */
 export type EventDependency = {
-  id: string
+  id: string;
   /**
    * Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.
    */
-  type: string
-}
+  type: string;
+};
 
 /**
  * Canonical error container that provides a structured way to represent errors
@@ -247,8 +250,17 @@ export type DataError = {
    * by clients to programmatically handle different error types.
    * Examples: "NOT_FOUND", "VALIDATION_ERROR", "TIMEOUT"
    */
-  code: string
-  context?: any | null | undefined
+  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 | null | undefined;
   /**
    * HTTP status code for this error.
    *
@@ -257,7 +269,7 @@ export type DataError = {
    * 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
+  httpStatusCode?: number | null | undefined;
   /**
    * Indicates if this is an internal error that should not be exposed to users.
    *
@@ -267,7 +279,7 @@ export type DataError = {
    * 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
+  internal: boolean;
   /**
    * Human-readable error message.
    *
@@ -276,7 +288,7 @@ export type DataError = {
    * 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
+  message: string;
   /**
    * Indicates whether the operation that caused the error should be retried.
    *
@@ -286,22 +298,35 @@ export type DataError = {
    * if attempted again. When `false`, retrying the same operation is
    * unlikely to succeed without changes.
    */
-  retryable: boolean
-  source?: any | null | undefined
-}
+  retryable: boolean;
+  /**
+   * 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 | null | undefined;
+};
+
+export type DataErrorUnion = DataError | any;
 
 /**
  * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
  */
-export const EventLifecycle = {
+export const EventLifecycleEnum = {
   Frozen: "frozen",
   Live: "live",
   LiveOnSetup: "live-on-setup",
-} as const
+} as const;
 /**
  * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
  */
-export type EventLifecycle = ClosedEnum<typeof EventLifecycle>
+export type EventLifecycleEnum = ClosedEnum<typeof EventLifecycleEnum>;
+
+export type EventLifecycleUnion = EventLifecycleEnum | any;
 
 /**
  * Resource outputs that can hold output data for any resource type in the Alien system. All resource outputs share a common 'type' field with additional type-specific output properties.
@@ -310,9 +335,11 @@ export type EventOutputs = {
   /**
    * Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.
    */
-  type: string
-  additionalProperties?: { [k: string]: any | null } | undefined
-}
+  type: string;
+  additionalProperties?: { [k: string]: any | null } | undefined;
+};
+
+export type EventOutputsUnion = EventOutputs | any;
 
 /**
  * Resource that can hold any resource type in the Alien system. All resources share common 'type' and 'id' fields with additional type-specific properties.
@@ -321,13 +348,15 @@ export type EventPreviousConfig = {
   /**
    * The unique identifier for this specific resource instance. Must contain only alphanumeric characters, hyphens, and underscores ([A-Za-z0-9-_]). Maximum 64 characters.
    */
-  id: string
+  id: string;
   /**
    * Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.
    */
-  type: string
-  additionalProperties?: { [k: string]: any | null } | undefined
-}
+  type: string;
+  additionalProperties?: { [k: string]: any | null } | undefined;
+};
+
+export type EventPreviousConfigUnion = EventPreviousConfig | any;
 
 /**
  * Represents the high-level status of a resource during its lifecycle.
@@ -343,54 +372,76 @@ export const EventStatus = {
   DeleteFailed: "delete-failed",
   Deleted: "deleted",
   RefreshFailed: "refresh-failed",
-} as const
+} as const;
 /**
  * Represents the high-level status of a resource during its lifecycle.
  */
-export type EventStatus = ClosedEnum<typeof EventStatus>
+export type EventStatus = ClosedEnum<typeof EventStatus>;
 
 /**
  * Represents the state of a single resource within the stack for a specific platform.
  */
 export type EventResources = {
-  internal?: any | null | undefined
+  /**
+   * The platform-specific resource controller that manages this resource's lifecycle.
+   *
+   * @remarks
+   * This is None when the resource status is Pending.
+   * Stored as JSON to make the struct serializable and movable to alien-core.
+   */
+  internal?: any | null | undefined;
   /**
    * Resource that can hold any resource type in the Alien system. All resources share common 'type' and 'id' fields with additional type-specific properties.
    */
-  config: EventConfig
+  config: EventConfig;
   /**
    * Complete list of dependencies for this resource, including infrastructure dependencies.
    *
    * @remarks
    * This preserves the full dependency information from the stack definition.
    */
-  dependencies?: Array<EventDependency> | undefined
-  error?: any | null | undefined
+  dependencies?: Array<EventDependency> | undefined;
+  error?: DataError | any | null | undefined;
   /**
    * True if the resource was provisioned by an external system (e.g., CloudFormation).
    *
    * @remarks
    * Defaults to false, indicating dynamic provisioning by the executor.
    */
-  isExternallyProvisioned?: boolean | undefined
-  lastFailedState?: any | null | undefined
-  lifecycle?: any | null | undefined
-  outputs?: any | null | undefined
-  previousConfig?: any | null | undefined
-  remoteBindingParams?: any | null | undefined
+  isExternallyProvisioned?: boolean | undefined;
+  /**
+   * Stores the controller state that failed, used for manual retry operations.
+   *
+   * @remarks
+   * This allows resuming from the exact point where the failure occurred.
+   * Stored as JSON to make the struct serializable and movable to alien-core.
+   */
+  lastFailedState?: any | null | undefined;
+  lifecycle?: EventLifecycleEnum | any | null | undefined;
+  outputs?: EventOutputs | any | null | undefined;
+  previousConfig?: EventPreviousConfig | any | null | undefined;
+  /**
+   * Binding parameters for remote access.
+   *
+   * @remarks
+   * Only populated when the resource has `remote_access: true` in its ResourceEntry.
+   * This is the JSON serialization of the binding configuration (e.g., StorageBinding, VaultBinding).
+   * Populated by controllers during provisioning using get_binding_params().
+   */
+  remoteBindingParams?: any | null | undefined;
   /**
    * Tracks consecutive retry attempts for the current state transition.
    */
-  retryAttempt?: number | undefined
+  retryAttempt?: number | undefined;
   /**
    * Represents the high-level status of a resource during its lifecycle.
    */
-  status: EventStatus
+  status: EventStatus;
   /**
    * The high-level type of the resource (e.g., Function::RESOURCE_TYPE, Storage::RESOURCE_TYPE).
    */
-  type: string
-}
+  type: string;
+};
 
 /**
  * Represents the collective state of all resources in a stack, including platform and pending actions.
@@ -399,72 +450,72 @@ export type NextState = {
   /**
    * Represents the target cloud platform.
    */
-  platform: EventPlatform
+  platform: EventPlatform;
   /**
    * A prefix used for resource naming to ensure uniqueness across deployments.
    */
-  resourcePrefix: string
+  resourcePrefix: string;
   /**
    * The state of individual resources, keyed by resource ID.
    */
-  resources: { [k: string]: EventResources }
-}
+  resources: { [k: string]: EventResources };
+};
 
 export type DataStackStep = {
   /**
    * Represents the collective state of all resources in a stack, including platform and pending actions.
    */
-  nextState: NextState
+  nextState: NextState;
   /**
    * An suggested duration to wait before executing the next step.
    */
-  suggestedDelayMs?: number | null | undefined
-  type: "StackStep"
-}
+  suggestedDelayMs?: number | null | undefined;
+  type: "StackStep";
+};
 
 export type DataCompilingCode = {
   /**
    * Language being compiled (rust, typescript, etc.)
    */
-  language: string
+  language: string;
   /**
    * Current progress/status line from the build output
    */
-  progress?: string | null | undefined
-  type: "CompilingCode"
-}
+  progress?: string | null | undefined;
+  type: "CompilingCode";
+};
 
 export type DataCreatingRelease = {
   /**
    * Project name
    */
-  project: string
-  type: "CreatingRelease"
-}
+  project: string;
+  type: "CreatingRelease";
+};
 
 export type DataPushingResource = {
   /**
    * Name of the resource being pushed
    */
-  resourceName: string
+  resourceName: string;
   /**
    * Type of the resource: "function", "container", "worker"
    */
-  resourceType: string
-  type: "PushingResource"
-}
+  resourceType: string;
+  type: "PushingResource";
+};
 
 export type DataPushingStack = {
   /**
    * Target platform
    */
-  platform: string
+  platform: string;
   /**
    * Name of the stack being pushed
    */
-  stack: string
-  type: "PushingStack"
-}
+  stack: string;
+  type: "PushingStack";
+};
 
 /**
  * Progress information for image push operations
@@ -473,97 +524,99 @@ export type Progress = {
   /**
    * Bytes uploaded so far
    */
-  bytesUploaded: number
+  bytesUploaded: number;
   /**
    * Number of layers uploaded so far
    */
-  layersUploaded: number
+  layersUploaded: number;
   /**
    * Current operation being performed
    */
-  operation: string
+  operation: string;
   /**
    * Total bytes to upload
    */
-  totalBytes: number
+  totalBytes: number;
   /**
    * Total number of layers to upload
    */
-  totalLayers: number
-}
+  totalLayers: number;
+};
+
+export type ProgressUnion = Progress | any;
 
 export type DataPushingImage = {
   /**
    * Name of the image being pushed
    */
-  image: string
-  progress?: any | null | undefined
-  type: "PushingImage"
-}
+  image: string;
+  progress?: Progress | any | null | undefined;
+  type: "PushingImage";
+};
 
 export type DataBuildingImage = {
   /**
    * Name of the image being built
    */
-  image: string
-  type: "BuildingImage"
-}
+  image: string;
+  type: "BuildingImage";
+};
 
 export type DataBuildingResource = {
   /**
    * All resource names sharing this build (for deduped container groups)
    */
-  relatedResources?: Array<string> | undefined
+  relatedResources?: Array<string> | undefined;
   /**
    * Name of the resource being built
    */
-  resourceName: string
+  resourceName: string;
   /**
    * Type of the resource: "function", "container", "worker"
    */
-  resourceType: string
-  type: "BuildingResource"
-}
+  resourceType: string;
+  type: "BuildingResource";
+};
 
 export type DataDownloadingAlienRuntime = {
   /**
    * Target triple for the runtime
    */
-  targetTriple: string
-  type: "DownloadingAlienRuntime"
+  targetTriple: string;
+  type: "DownloadingAlienRuntime";
   /**
    * URL being downloaded from
    */
-  url: string
-}
+  url: string;
+};
 
 export type DataRunningPreflights = {
   /**
    * Platform being targeted
    */
-  platform: string
+  platform: string;
   /**
    * Name of the stack being checked
    */
-  stack: string
-  type: "RunningPreflights"
-}
+  stack: string;
+  type: "RunningPreflights";
+};
 
 export type DataBuildingStack = {
   /**
    * Name of the stack being built
    */
-  stack: string
-  type: "BuildingStack"
-}
+  stack: string;
+  type: "BuildingStack";
+};
 
 export type DataFinished = {
-  type: "Finished"
-}
+  type: "Finished";
+};
 
 export type DataLoadingConfiguration = {
-  type: "LoadingConfiguration"
-}
+  type: "LoadingConfiguration";
+};
 
 /**
  * Represents all possible events in the Alien system
@@ -599,22 +652,22 @@ export type Data =
   | DataAssumingRole
   | DataImportingStackStateFromCloudFormation
   | DataDeletingCloudFormationStack
-  | DataEmptyingBuckets
+  | DataEmptyingBuckets;
 
 export const StateSuccess = {
   Success: "success",
-} as const
-export type StateSuccess = ClosedEnum<typeof StateSuccess>
+} as const;
+export type StateSuccess = ClosedEnum<typeof StateSuccess>;
 
 export const StateStarted = {
   Started: "started",
-} as const
-export type StateStarted = ClosedEnum<typeof StateStarted>
+} as const;
+export type StateStarted = ClosedEnum<typeof StateStarted>;
 
 export const StateNone = {
   None: "none",
-} as const
-export type StateNone = ClosedEnum<typeof StateNone>
+} as const;
+export type StateNone = ClosedEnum<typeof StateNone>;
 
 /**
  * Canonical error container that provides a structured way to represent errors
@@ -637,8 +690,17 @@ export type ErrorFailed = {
    * by clients to programmatically handle different error types.
    * Examples: "NOT_FOUND", "VALIDATION_ERROR", "TIMEOUT"
    */
-  code: string
-  context?: any | null | undefined
+  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 | null | undefined;
   /**
    * HTTP status code for this error.
    *
@@ -647,7 +709,7 @@ export type ErrorFailed = {
    * 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
+  httpStatusCode?: number | null | undefined;
   /**
    * Indicates if this is an internal error that should not be exposed to users.
    *
@@ -657,7 +719,7 @@ export type ErrorFailed = {
    * 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
+  internal: boolean;
   /**
    * Human-readable error message.
    *
@@ -666,7 +728,7 @@ export type ErrorFailed = {
    * 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
+  message: string;
   /**
    * Indicates whether the operation that caused the error should be retried.
    *
@@ -676,46 +738,57 @@ export type ErrorFailed = {
    * if attempted again. When `false`, retrying the same operation is
    * unlikely to succeed without changes.
    */
-  retryable: boolean
-  source?: any | null | undefined
-}
+  retryable: boolean;
+  /**
+   * 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 | null | undefined;
+};
+
+export type FailedErrorUnion = ErrorFailed | any;
 
 /**
  * Event failed with an error
  */
 export type Failed = {
-  error?: any | null | undefined
-}
+  error?: ErrorFailed | any | null | undefined;
+};
 
 export type EventState = {
   /**
    * Event failed with an error
    */
-  failed: Failed
-}
+  failed: Failed;
+};
 
 /**
  * Represents the state of an event
  */
-export type State = EventState | StateNone | StateStarted | StateSuccess
+export type State = EventState | StateNone | StateStarted | StateSuccess;
 
 export type Event = {
   /**
    * Unique identifier for the event.
    */
-  id: string
+  id: string;
   /**
    * Unique identifier for the deployment.
    */
-  deploymentId?: string | null | undefined
+  deploymentId?: string | null | undefined;
   /**
    * Unique identifier for the release.
    */
-  releaseId?: string | null | undefined
+  releaseId?: string | null | undefined;
   /**
    * Unique identifier for the debug session.
    */
-  debugSessionId?: string | null | undefined
+  debugSessionId?: string | null | undefined;
   /**
    * Represents all possible events in the Alien system
    */
@@ -750,36 +823,39 @@ export type Event = {
     | DataAssumingRole
     | DataImportingStackStateFromCloudFormation
     | DataDeletingCloudFormationStack
-    | DataEmptyingBuckets
+    | DataEmptyingBuckets;
   /**
    * Represents the state of an event
    */
-  state: EventState | StateNone | StateStarted | StateSuccess
+  state: EventState | StateNone | StateStarted | StateSuccess;
   /**
    * Unique identifier for the project.
    */
-  projectId: string
-  createdAt: Date
+  projectId: string;
+  createdAt: Date;
   /**
    * Unique identifier for the workspace.
    */
-  workspaceId: string
-}
+  workspaceId: string;
+};
 
 /** @internal */
-export const DataEmptyingBuckets$inboundSchema: z.ZodType<DataEmptyingBuckets, unknown> = z.object({
+export const DataEmptyingBuckets$inboundSchema: z.ZodType<
+  DataEmptyingBuckets,
+  unknown
+> = z.object({
   bucketNames: z.array(z.string()),
   type: z.literal("EmptyingBuckets"),
-})
+});
 
 export function dataEmptyingBucketsFromJSON(
   jsonString: string,
 ): SafeParseResult<DataEmptyingBuckets, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataEmptyingBuckets$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataEmptyingBuckets$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataEmptyingBuckets' from JSON`,
-  )
+  );
 }
 
 /** @internal */
@@ -790,16 +866,16 @@ export const DataDeletingCloudFormationStack$inboundSchema: z.ZodType<
   cfnStackName: z.string(),
   currentStatus: z.string(),
   type: z.literal("DeletingCloudFormationStack"),
-})
+});
 
 export function dataDeletingCloudFormationStackFromJSON(
   jsonString: string,
 ): SafeParseResult<DataDeletingCloudFormationStack, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataDeletingCloudFormationStack$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataDeletingCloudFormationStack$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataDeletingCloudFormationStack' from JSON`,
-  )
+  );
 }
 
 /** @internal */
@@ -809,32 +885,41 @@ export const DataImportingStackStateFromCloudFormation$inboundSchema: z.ZodType<
 > = z.object({
   cfnStackName: z.string(),
   type: z.literal("ImportingStackStateFromCloudFormation"),
-})
+});
 
 export function dataImportingStackStateFromCloudFormationFromJSON(
   jsonString: string,
-): SafeParseResult<DataImportingStackStateFromCloudFormation, SDKValidationError> {
+): SafeParseResult<
+  DataImportingStackStateFromCloudFormation,
+  SDKValidationError
+> {
   return safeParse(
     jsonString,
-    x => DataImportingStackStateFromCloudFormation$inboundSchema.parse(JSON.parse(x)),
+    (x) =>
+      DataImportingStackStateFromCloudFormation$inboundSchema.parse(
+        JSON.parse(x),
+      ),
     `Failed to parse 'DataImportingStackStateFromCloudFormation' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const DataAssumingRole$inboundSchema: z.ZodType<DataAssumingRole, unknown> = z.object({
+export const DataAssumingRole$inboundSchema: z.ZodType<
+  DataAssumingRole,
+  unknown
+> = z.object({
   roleArn: z.string(),
   type: z.literal("AssumingRole"),
-})
+});
 
 export function dataAssumingRoleFromJSON(
   jsonString: string,
 ): SafeParseResult<DataAssumingRole, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataAssumingRole$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataAssumingRole$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataAssumingRole' from JSON`,
-  )
+  );
 }
 
 /** @internal */
@@ -845,16 +930,16 @@ export const DataDeployingCloudFormationStack$inboundSchema: z.ZodType<
   cfnStackName: z.string(),
   currentStatus: z.string(),
   type: z.literal("DeployingCloudFormationStack"),
-})
+});
 
 export function dataDeployingCloudFormationStackFromJSON(
   jsonString: string,
 ): SafeParseResult<DataDeployingCloudFormationStack, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataDeployingCloudFormationStack$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataDeployingCloudFormationStack$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataDeployingCloudFormationStack' from JSON`,
-  )
+  );
 }
 
 /** @internal */
@@ -864,16 +949,16 @@ export const DataEnsuringDockerRepository$inboundSchema: z.ZodType<
 > = z.object({
   repositoryName: z.string(),
   type: z.literal("EnsuringDockerRepository"),
-})
+});
 
 export function dataEnsuringDockerRepositoryFromJSON(
   jsonString: string,
 ): SafeParseResult<DataEnsuringDockerRepository, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataEnsuringDockerRepository$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataEnsuringDockerRepository$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataEnsuringDockerRepository' from JSON`,
-  )
+  );
 }
 
 /** @internal */
@@ -883,16 +968,16 @@ export const DataSettingUpPlatformContext$inboundSchema: z.ZodType<
 > = z.object({
   platformName: z.string(),
   type: z.literal("SettingUpPlatformContext"),
-})
+});
 
 export function dataSettingUpPlatformContextFromJSON(
   jsonString: string,
 ): SafeParseResult<DataSettingUpPlatformContext, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataSettingUpPlatformContext$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataSettingUpPlatformContext$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataSettingUpPlatformContext' from JSON`,
-  )
+  );
 }
 
 /** @internal */
@@ -903,169 +988,192 @@ export const DataCleaningUpEnvironment$inboundSchema: z.ZodType<
   stackName: z.string(),
   strategyName: z.string(),
   type: z.literal("CleaningUpEnvironment"),
-})
+});
 
 export function dataCleaningUpEnvironmentFromJSON(
   jsonString: string,
 ): SafeParseResult<DataCleaningUpEnvironment, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataCleaningUpEnvironment$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataCleaningUpEnvironment$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataCleaningUpEnvironment' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const DataCleaningUpStack$inboundSchema: z.ZodType<DataCleaningUpStack, unknown> = z.object({
+export const DataCleaningUpStack$inboundSchema: z.ZodType<
+  DataCleaningUpStack,
+  unknown
+> = z.object({
   stackName: z.string(),
   strategyName: z.string(),
   type: z.literal("CleaningUpStack"),
-})
+});
 
 export function dataCleaningUpStackFromJSON(
   jsonString: string,
 ): SafeParseResult<DataCleaningUpStack, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataCleaningUpStack$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataCleaningUpStack$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataCleaningUpStack' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const DataRunningTestFunction$inboundSchema: z.ZodType<DataRunningTestFunction, unknown> =
-  z.object({
-    stackName: z.string(),
-    type: z.literal("RunningTestFunction"),
-  })
+export const DataRunningTestFunction$inboundSchema: z.ZodType<
+  DataRunningTestFunction,
+  unknown
+> = z.object({
+  stackName: z.string(),
+  type: z.literal("RunningTestFunction"),
+});
 
 export function dataRunningTestFunctionFromJSON(
   jsonString: string,
 ): SafeParseResult<DataRunningTestFunction, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataRunningTestFunction$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataRunningTestFunction$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataRunningTestFunction' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const DataDeployingStack$inboundSchema: z.ZodType<DataDeployingStack, unknown> = z.object({
+export const DataDeployingStack$inboundSchema: z.ZodType<
+  DataDeployingStack,
+  unknown
+> = z.object({
   stackName: z.string(),
   type: z.literal("DeployingStack"),
-})
+});
 
 export function dataDeployingStackFromJSON(
   jsonString: string,
 ): SafeParseResult<DataDeployingStack, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataDeployingStack$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataDeployingStack$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataDeployingStack' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const DataPreparingEnvironment$inboundSchema: z.ZodType<DataPreparingEnvironment, unknown> =
-  z.object({
-    strategyName: z.string(),
-    type: z.literal("PreparingEnvironment"),
-  })
+export const DataPreparingEnvironment$inboundSchema: z.ZodType<
+  DataPreparingEnvironment,
+  unknown
+> = z.object({
+  strategyName: z.string(),
+  type: z.literal("PreparingEnvironment"),
+});
 
 export function dataPreparingEnvironmentFromJSON(
   jsonString: string,
 ): SafeParseResult<DataPreparingEnvironment, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataPreparingEnvironment$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataPreparingEnvironment$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataPreparingEnvironment' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const DataDebuggingAgent$inboundSchema: z.ZodType<DataDebuggingAgent, unknown> = z.object({
+export const DataDebuggingAgent$inboundSchema: z.ZodType<
+  DataDebuggingAgent,
+  unknown
+> = z.object({
   agentId: z.string(),
   debugSessionId: z.string(),
   type: z.literal("DebuggingAgent"),
-})
+});
 
 export function dataDebuggingAgentFromJSON(
   jsonString: string,
 ): SafeParseResult<DataDebuggingAgent, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataDebuggingAgent$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataDebuggingAgent$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataDebuggingAgent' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const DataDeletingAgent$inboundSchema: z.ZodType<DataDeletingAgent, unknown> = z.object({
+export const DataDeletingAgent$inboundSchema: z.ZodType<
+  DataDeletingAgent,
+  unknown
+> = z.object({
   agentId: z.string(),
   releaseId: z.string(),
   type: z.literal("DeletingAgent"),
-})
+});
 
 export function dataDeletingAgentFromJSON(
   jsonString: string,
 ): SafeParseResult<DataDeletingAgent, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataDeletingAgent$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataDeletingAgent$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataDeletingAgent' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const DataUpdatingAgent$inboundSchema: z.ZodType<DataUpdatingAgent, unknown> = z.object({
+export const DataUpdatingAgent$inboundSchema: z.ZodType<
+  DataUpdatingAgent,
+  unknown
+> = z.object({
   agentId: z.string(),
   releaseId: z.string(),
   type: z.literal("UpdatingAgent"),
-})
+});
 
 export function dataUpdatingAgentFromJSON(
   jsonString: string,
 ): SafeParseResult<DataUpdatingAgent, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataUpdatingAgent$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataUpdatingAgent$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataUpdatingAgent' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const DataProvisioningAgent$inboundSchema: z.ZodType<DataProvisioningAgent, unknown> =
-  z.object({
-    agentId: z.string(),
-    releaseId: z.string(),
-    type: z.literal("ProvisioningAgent"),
-  })
+export const DataProvisioningAgent$inboundSchema: z.ZodType<
+  DataProvisioningAgent,
+  unknown
+> = z.object({
+  agentId: z.string(),
+  releaseId: z.string(),
+  type: z.literal("ProvisioningAgent"),
+});
 
 export function dataProvisioningAgentFromJSON(
   jsonString: string,
 ): SafeParseResult<DataProvisioningAgent, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataProvisioningAgent$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataProvisioningAgent$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataProvisioningAgent' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const DataGeneratingTemplate$inboundSchema: z.ZodType<DataGeneratingTemplate, unknown> =
-  z.object({
-    platform: z.string(),
-    type: z.literal("GeneratingTemplate"),
-  })
+export const DataGeneratingTemplate$inboundSchema: z.ZodType<
+  DataGeneratingTemplate,
+  unknown
+> = z.object({
+  platform: z.string(),
+  type: z.literal("GeneratingTemplate"),
+});
 
 export function dataGeneratingTemplateFromJSON(
   jsonString: string,
 ): SafeParseResult<DataGeneratingTemplate, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataGeneratingTemplate$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataGeneratingTemplate$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataGeneratingTemplate' from JSON`,
-  )
+  );
 }
 
 /** @internal */
@@ -1074,57 +1182,61 @@ export const DataGeneratingCloudFormationTemplate$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   type: z.literal("GeneratingCloudFormationTemplate"),
-})
+});
 
 export function dataGeneratingCloudFormationTemplateFromJSON(
   jsonString: string,
 ): SafeParseResult<DataGeneratingCloudFormationTemplate, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataGeneratingCloudFormationTemplate$inboundSchema.parse(JSON.parse(x)),
+    (x) =>
+      DataGeneratingCloudFormationTemplate$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataGeneratingCloudFormationTemplate' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const EventPlatform$inboundSchema: z.ZodEnum<typeof EventPlatform> = z.enum(EventPlatform)
+export const EventPlatform$inboundSchema: z.ZodEnum<typeof EventPlatform> = z
+  .enum(EventPlatform);
 
 /** @internal */
-export const EventConfig$inboundSchema: z.ZodType<EventConfig, unknown> = collectExtraKeys$(
-  z
-    .object({
+export const EventConfig$inboundSchema: z.ZodType<EventConfig, unknown> =
+  collectExtraKeys$(
+    z.object({
       id: z.string(),
       type: z.string(),
-    })
-    .catchall(z.any()),
-  "additionalProperties",
-  true,
-)
+    }).catchall(z.any()),
+    "additionalProperties",
+    true,
+  );
 
 export function eventConfigFromJSON(
   jsonString: string,
 ): SafeParseResult<EventConfig, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => EventConfig$inboundSchema.parse(JSON.parse(x)),
+    (x) => EventConfig$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'EventConfig' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const EventDependency$inboundSchema: z.ZodType<EventDependency, unknown> = z.object({
+export const EventDependency$inboundSchema: z.ZodType<
+  EventDependency,
+  unknown
+> = z.object({
   id: z.string(),
   type: z.string(),
-})
+});
 
 export function eventDependencyFromJSON(
   jsonString: string,
 ): SafeParseResult<EventDependency, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => EventDependency$inboundSchema.parse(JSON.parse(x)),
+    (x) => EventDependency$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'EventDependency' from JSON`,
-  )
+  );
 }
 
 /** @internal */
@@ -1136,203 +1248,284 @@ export const DataError$inboundSchema: z.ZodType<DataError, unknown> = z.object({
   message: z.string(),
   retryable: z.boolean().default(false),
   source: z.nullable(z.any()).optional(),
-})
+});
 
 export function dataErrorFromJSON(
   jsonString: string,
 ): SafeParseResult<DataError, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataError$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataError$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataError' from JSON`,
-  )
+  );
+}
+
+/** @internal */
+export const DataErrorUnion$inboundSchema: z.ZodType<DataErrorUnion, unknown> =
+  z.union([z.lazy(() => DataError$inboundSchema), z.any()]);
+
+export function dataErrorUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<DataErrorUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DataErrorUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DataErrorUnion' from JSON`,
+  );
 }
 
 /** @internal */
-export const EventLifecycle$inboundSchema: z.ZodEnum<typeof EventLifecycle> = z.enum(EventLifecycle)
+export const EventLifecycleEnum$inboundSchema: z.ZodEnum<
+  typeof EventLifecycleEnum
+> = z.enum(EventLifecycleEnum);
+
+/** @internal */
+export const EventLifecycleUnion$inboundSchema: z.ZodType<
+  EventLifecycleUnion,
+  unknown
+> = z.union([EventLifecycleEnum$inboundSchema, z.any()]);
+
+export function eventLifecycleUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<EventLifecycleUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EventLifecycleUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EventLifecycleUnion' from JSON`,
+  );
+}
 
 /** @internal */
-export const EventOutputs$inboundSchema: z.ZodType<EventOutputs, unknown> = collectExtraKeys$(
-  z
-    .object({
+export const EventOutputs$inboundSchema: z.ZodType<EventOutputs, unknown> =
+  collectExtraKeys$(
+    z.object({
       type: z.string(),
-    })
-    .catchall(z.any()),
-  "additionalProperties",
-  true,
-)
+    }).catchall(z.any()),
+    "additionalProperties",
+    true,
+  );
 
 export function eventOutputsFromJSON(
   jsonString: string,
 ): SafeParseResult<EventOutputs, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => EventOutputs$inboundSchema.parse(JSON.parse(x)),
+    (x) => EventOutputs$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'EventOutputs' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const EventPreviousConfig$inboundSchema: z.ZodType<EventPreviousConfig, unknown> =
-  collectExtraKeys$(
-    z
-      .object({
-        id: z.string(),
-        type: z.string(),
-      })
-      .catchall(z.any()),
-    "additionalProperties",
-    true,
-  )
+export const EventOutputsUnion$inboundSchema: z.ZodType<
+  EventOutputsUnion,
+  unknown
+> = z.union([z.lazy(() => EventOutputs$inboundSchema), z.any()]);
+
+export function eventOutputsUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<EventOutputsUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EventOutputsUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EventOutputsUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const EventPreviousConfig$inboundSchema: z.ZodType<
+  EventPreviousConfig,
+  unknown
+> = collectExtraKeys$(
+  z.object({
+    id: z.string(),
+    type: z.string(),
+  }).catchall(z.any()),
+  "additionalProperties",
+  true,
+);
 
 export function eventPreviousConfigFromJSON(
   jsonString: string,
 ): SafeParseResult<EventPreviousConfig, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => EventPreviousConfig$inboundSchema.parse(JSON.parse(x)),
+    (x) => EventPreviousConfig$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'EventPreviousConfig' from JSON`,
-  )
+  );
+}
+
+/** @internal */
+export const EventPreviousConfigUnion$inboundSchema: z.ZodType<
+  EventPreviousConfigUnion,
+  unknown
+> = z.union([z.lazy(() => EventPreviousConfig$inboundSchema), z.any()]);
+
+export function eventPreviousConfigUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<EventPreviousConfigUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EventPreviousConfigUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EventPreviousConfigUnion' from JSON`,
+  );
 }
 
 /** @internal */
-export const EventStatus$inboundSchema: z.ZodEnum<typeof EventStatus> = z.enum(EventStatus)
+export const EventStatus$inboundSchema: z.ZodEnum<typeof EventStatus> = z.enum(
+  EventStatus,
+);
 
 /** @internal */
-export const EventResources$inboundSchema: z.ZodType<EventResources, unknown> = z
-  .object({
+export const EventResources$inboundSchema: z.ZodType<EventResources, unknown> =
+  z.object({
     _internal: z.nullable(z.any()).optional(),
     config: z.lazy(() => EventConfig$inboundSchema),
-    dependencies: z.array(z.lazy(() => EventDependency$inboundSchema)).optional(),
-    error: z.nullable(z.any()).optional(),
+    dependencies: z.array(z.lazy(() => EventDependency$inboundSchema))
+      .optional(),
+    error: z.nullable(z.union([z.lazy(() => DataError$inboundSchema), z.any()]))
+      .optional(),
     isExternallyProvisioned: z.boolean().optional(),
     lastFailedState: z.nullable(z.any()).optional(),
-    lifecycle: z.nullable(z.any()).optional(),
-    outputs: z.nullable(z.any()).optional(),
-    previousConfig: z.nullable(z.any()).optional(),
+    lifecycle: z.nullable(z.union([EventLifecycleEnum$inboundSchema, z.any()]))
+      .optional(),
+    outputs: z.nullable(
+      z.union([z.lazy(() => EventOutputs$inboundSchema), z.any()]),
+    ).optional(),
+    previousConfig: z.nullable(
+      z.union([z.lazy(() => EventPreviousConfig$inboundSchema), z.any()]),
+    ).optional(),
     remoteBindingParams: z.nullable(z.any()).optional(),
     retryAttempt: z.int().optional(),
     status: EventStatus$inboundSchema,
     type: z.string(),
-  })
-  .transform(v => {
+  }).transform((v) => {
     return remap$(v, {
-      _internal: "internal",
-    })
-  })
+      "_internal": "internal",
+    });
+  });
 
 export function eventResourcesFromJSON(
   jsonString: string,
 ): SafeParseResult<EventResources, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => EventResources$inboundSchema.parse(JSON.parse(x)),
+    (x) => EventResources$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'EventResources' from JSON`,
-  )
+  );
 }
 
 /** @internal */
 export const NextState$inboundSchema: z.ZodType<NextState, unknown> = z.object({
   platform: EventPlatform$inboundSchema,
   resourcePrefix: z.string(),
-  resources: z.record(
-    z.string(),
-    z.lazy(() => EventResources$inboundSchema),
-  ),
-})
+  resources: z.record(z.string(), z.lazy(() => EventResources$inboundSchema)),
+});
 
 export function nextStateFromJSON(
   jsonString: string,
 ): SafeParseResult<NextState, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => NextState$inboundSchema.parse(JSON.parse(x)),
+    (x) => NextState$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'NextState' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const DataStackStep$inboundSchema: z.ZodType<DataStackStep, unknown> = z.object({
-  nextState: z.lazy(() => NextState$inboundSchema),
-  suggestedDelayMs: z.nullable(z.int()).optional(),
-  type: z.literal("StackStep"),
-})
+export const DataStackStep$inboundSchema: z.ZodType<DataStackStep, unknown> = z
+  .object({
+    nextState: z.lazy(() => NextState$inboundSchema),
+    suggestedDelayMs: z.nullable(z.int()).optional(),
+    type: z.literal("StackStep"),
+  });
 
 export function dataStackStepFromJSON(
   jsonString: string,
 ): SafeParseResult<DataStackStep, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataStackStep$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataStackStep$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataStackStep' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const DataCompilingCode$inboundSchema: z.ZodType<DataCompilingCode, unknown> = z.object({
+export const DataCompilingCode$inboundSchema: z.ZodType<
+  DataCompilingCode,
+  unknown
+> = z.object({
   language: z.string(),
   progress: z.nullable(z.string()).optional(),
   type: z.literal("CompilingCode"),
-})
+});
 
 export function dataCompilingCodeFromJSON(
   jsonString: string,
 ): SafeParseResult<DataCompilingCode, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataCompilingCode$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataCompilingCode$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataCompilingCode' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const DataCreatingRelease$inboundSchema: z.ZodType<DataCreatingRelease, unknown> = z.object({
+export const DataCreatingRelease$inboundSchema: z.ZodType<
+  DataCreatingRelease,
+  unknown
+> = z.object({
   project: z.string(),
   type: z.literal("CreatingRelease"),
-})
+});
 
 export function dataCreatingReleaseFromJSON(
   jsonString: string,
 ): SafeParseResult<DataCreatingRelease, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataCreatingRelease$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataCreatingRelease$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataCreatingRelease' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const DataPushingResource$inboundSchema: z.ZodType<DataPushingResource, unknown> = z.object({
+export const DataPushingResource$inboundSchema: z.ZodType<
+  DataPushingResource,
+  unknown
+> = z.object({
   resourceName: z.string(),
   resourceType: z.string(),
   type: z.literal("PushingResource"),
-})
+});
 
 export function dataPushingResourceFromJSON(
   jsonString: string,
 ): SafeParseResult<DataPushingResource, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataPushingResource$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataPushingResource$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataPushingResource' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const DataPushingStack$inboundSchema: z.ZodType<DataPushingStack, unknown> = z.object({
+export const DataPushingStack$inboundSchema: z.ZodType<
+  DataPushingStack,
+  unknown
+> = z.object({
   platform: z.string(),
   stack: z.string(),
   type: z.literal("PushingStack"),
-})
+});
 
 export function dataPushingStackFromJSON(
   jsonString: string,
 ): SafeParseResult<DataPushingStack, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataPushingStack$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataPushingStack$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataPushingStack' from JSON`,
-  )
+  );
 }
 
 /** @internal */
@@ -1342,68 +1535,91 @@ export const Progress$inboundSchema: z.ZodType<Progress, unknown> = z.object({
   operation: z.string(),
   totalBytes: z.int(),
   totalLayers: z.int(),
-})
+});
 
 export function progressFromJSON(
   jsonString: string,
 ): SafeParseResult<Progress, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => Progress$inboundSchema.parse(JSON.parse(x)),
+    (x) => Progress$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'Progress' from JSON`,
-  )
+  );
+}
+
+/** @internal */
+export const ProgressUnion$inboundSchema: z.ZodType<ProgressUnion, unknown> = z
+  .union([z.lazy(() => Progress$inboundSchema), z.any()]);
+
+export function progressUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<ProgressUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProgressUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProgressUnion' from JSON`,
+  );
 }
 
 /** @internal */
-export const DataPushingImage$inboundSchema: z.ZodType<DataPushingImage, unknown> = z.object({
+export const DataPushingImage$inboundSchema: z.ZodType<
+  DataPushingImage,
+  unknown
+> = z.object({
   image: z.string(),
-  progress: z.nullable(z.any()).optional(),
+  progress: z.nullable(z.union([z.lazy(() => Progress$inboundSchema), z.any()]))
+    .optional(),
   type: z.literal("PushingImage"),
-})
+});
 
 export function dataPushingImageFromJSON(
   jsonString: string,
 ): SafeParseResult<DataPushingImage, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataPushingImage$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataPushingImage$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataPushingImage' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const DataBuildingImage$inboundSchema: z.ZodType<DataBuildingImage, unknown> = z.object({
+export const DataBuildingImage$inboundSchema: z.ZodType<
+  DataBuildingImage,
+  unknown
+> = z.object({
   image: z.string(),
   type: z.literal("BuildingImage"),
-})
+});
 
 export function dataBuildingImageFromJSON(
   jsonString: string,
 ): SafeParseResult<DataBuildingImage, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataBuildingImage$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataBuildingImage$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataBuildingImage' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const DataBuildingResource$inboundSchema: z.ZodType<DataBuildingResource, unknown> =
-  z.object({
-    relatedResources: z.array(z.string()).optional(),
-    resourceName: z.string(),
-    resourceType: z.string(),
-    type: z.literal("BuildingResource"),
-  })
+export const DataBuildingResource$inboundSchema: z.ZodType<
+  DataBuildingResource,
+  unknown
+> = z.object({
+  relatedResources: z.array(z.string()).optional(),
+  resourceName: z.string(),
+  resourceType: z.string(),
+  type: z.literal("BuildingResource"),
+});
 
 export function dataBuildingResourceFromJSON(
   jsonString: string,
 ): SafeParseResult<DataBuildingResource, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataBuildingResource$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataBuildingResource$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataBuildingResource' from JSON`,
-  )
+  );
 }
 
 /** @internal */
@@ -1414,81 +1630,89 @@ export const DataDownloadingAlienRuntime$inboundSchema: z.ZodType<
   targetTriple: z.string(),
   type: z.literal("DownloadingAlienRuntime"),
   url: z.string(),
-})
+});
 
 export function dataDownloadingAlienRuntimeFromJSON(
   jsonString: string,
 ): SafeParseResult<DataDownloadingAlienRuntime, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataDownloadingAlienRuntime$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataDownloadingAlienRuntime$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataDownloadingAlienRuntime' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const DataRunningPreflights$inboundSchema: z.ZodType<DataRunningPreflights, unknown> =
-  z.object({
-    platform: z.string(),
-    stack: z.string(),
-    type: z.literal("RunningPreflights"),
-  })
+export const DataRunningPreflights$inboundSchema: z.ZodType<
+  DataRunningPreflights,
+  unknown
+> = z.object({
+  platform: z.string(),
+  stack: z.string(),
+  type: z.literal("RunningPreflights"),
+});
 
 export function dataRunningPreflightsFromJSON(
   jsonString: string,
 ): SafeParseResult<DataRunningPreflights, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataRunningPreflights$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataRunningPreflights$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataRunningPreflights' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const DataBuildingStack$inboundSchema: z.ZodType<DataBuildingStack, unknown> = z.object({
+export const DataBuildingStack$inboundSchema: z.ZodType<
+  DataBuildingStack,
+  unknown
+> = z.object({
   stack: z.string(),
   type: z.literal("BuildingStack"),
-})
+});
 
 export function dataBuildingStackFromJSON(
   jsonString: string,
 ): SafeParseResult<DataBuildingStack, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataBuildingStack$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataBuildingStack$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataBuildingStack' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const DataFinished$inboundSchema: z.ZodType<DataFinished, unknown> = z.object({
-  type: z.literal("Finished"),
-})
+export const DataFinished$inboundSchema: z.ZodType<DataFinished, unknown> = z
+  .object({
+    type: z.literal("Finished"),
+  });
 
 export function dataFinishedFromJSON(
   jsonString: string,
 ): SafeParseResult<DataFinished, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataFinished$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataFinished$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataFinished' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const DataLoadingConfiguration$inboundSchema: z.ZodType<DataLoadingConfiguration, unknown> =
-  z.object({
-    type: z.literal("LoadingConfiguration"),
-  })
+export const DataLoadingConfiguration$inboundSchema: z.ZodType<
+  DataLoadingConfiguration,
+  unknown
+> = z.object({
+  type: z.literal("LoadingConfiguration"),
+});
 
 export function dataLoadingConfigurationFromJSON(
   jsonString: string,
 ): SafeParseResult<DataLoadingConfiguration, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => DataLoadingConfiguration$inboundSchema.parse(JSON.parse(x)),
+    (x) => DataLoadingConfiguration$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'DataLoadingConfiguration' from JSON`,
-  )
+  );
 }
 
 /** @internal */
@@ -1524,72 +1748,99 @@ export const Data$inboundSchema: z.ZodType<Data, unknown> = z.union([
   z.lazy(() => DataImportingStackStateFromCloudFormation$inboundSchema),
   z.lazy(() => DataDeletingCloudFormationStack$inboundSchema),
   z.lazy(() => DataEmptyingBuckets$inboundSchema),
-])
+]);
 
-export function dataFromJSON(jsonString: string): SafeParseResult<Data, SDKValidationError> {
+export function dataFromJSON(
+  jsonString: string,
+): SafeParseResult<Data, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => Data$inboundSchema.parse(JSON.parse(x)),
+    (x) => Data$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'Data' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const StateSuccess$inboundSchema: z.ZodEnum<typeof StateSuccess> = z.enum(StateSuccess)
+export const StateSuccess$inboundSchema: z.ZodEnum<typeof StateSuccess> = z
+  .enum(StateSuccess);
 
 /** @internal */
-export const StateStarted$inboundSchema: z.ZodEnum<typeof StateStarted> = z.enum(StateStarted)
+export const StateStarted$inboundSchema: z.ZodEnum<typeof StateStarted> = z
+  .enum(StateStarted);
 
 /** @internal */
-export const StateNone$inboundSchema: z.ZodEnum<typeof StateNone> = z.enum(StateNone)
+export const StateNone$inboundSchema: z.ZodEnum<typeof StateNone> = z.enum(
+  StateNone,
+);
 
 /** @internal */
-export const ErrorFailed$inboundSchema: z.ZodType<ErrorFailed, unknown> = z.object({
-  code: z.string(),
-  context: z.nullable(z.any()).optional(),
-  httpStatusCode: z.nullable(z.int()).optional(),
-  internal: z.boolean(),
-  message: z.string(),
-  retryable: z.boolean().default(false),
-  source: z.nullable(z.any()).optional(),
-})
+export const ErrorFailed$inboundSchema: z.ZodType<ErrorFailed, unknown> = z
+  .object({
+    code: z.string(),
+    context: z.nullable(z.any()).optional(),
+    httpStatusCode: z.nullable(z.int()).optional(),
+    internal: z.boolean(),
+    message: z.string(),
+    retryable: z.boolean().default(false),
+    source: z.nullable(z.any()).optional(),
+  });
 
 export function errorFailedFromJSON(
   jsonString: string,
 ): SafeParseResult<ErrorFailed, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => ErrorFailed$inboundSchema.parse(JSON.parse(x)),
+    (x) => ErrorFailed$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'ErrorFailed' from JSON`,
-  )
+  );
+}
+
+/** @internal */
+export const FailedErrorUnion$inboundSchema: z.ZodType<
+  FailedErrorUnion,
+  unknown
+> = z.union([z.lazy(() => ErrorFailed$inboundSchema), z.any()]);
+
+export function failedErrorUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<FailedErrorUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FailedErrorUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FailedErrorUnion' from JSON`,
+  );
 }
 
 /** @internal */
 export const Failed$inboundSchema: z.ZodType<Failed, unknown> = z.object({
-  error: z.nullable(z.any()).optional(),
-})
+  error: z.nullable(z.union([z.lazy(() => ErrorFailed$inboundSchema), z.any()]))
+    .optional(),
+});
 
-export function failedFromJSON(jsonString: string): SafeParseResult<Failed, SDKValidationError> {
+export function failedFromJSON(
+  jsonString: string,
+): SafeParseResult<Failed, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => Failed$inboundSchema.parse(JSON.parse(x)),
+    (x) => Failed$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'Failed' from JSON`,
-  )
+  );
 }
 
 /** @internal */
-export const EventState$inboundSchema: z.ZodType<EventState, unknown> = z.object({
-  failed: z.lazy(() => Failed$inboundSchema),
-})
+export const EventState$inboundSchema: z.ZodType<EventState, unknown> = z
+  .object({
+    failed: z.lazy(() => Failed$inboundSchema),
+  });
 
 export function eventStateFromJSON(
   jsonString: string,
 ): SafeParseResult<EventState, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => EventState$inboundSchema.parse(JSON.parse(x)),
+    (x) => EventState$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'EventState' from JSON`,
-  )
+  );
 }
 
 /** @internal */
@@ -1598,14 +1849,16 @@ export const State$inboundSchema: z.ZodType<State, unknown> = z.union([
   StateNone$inboundSchema,
   StateStarted$inboundSchema,
   StateSuccess$inboundSchema,
-])
+]);
 
-export function stateFromJSON(jsonString: string): SafeParseResult<State, SDKValidationError> {
+export function stateFromJSON(
+  jsonString: string,
+): SafeParseResult<State, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => State$inboundSchema.parse(JSON.parse(x)),
+    (x) => State$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'State' from JSON`,
-  )
+  );
 }
 
 /** @internal */
@@ -1656,12 +1909,14 @@ export const Event$inboundSchema: z.ZodType<Event, unknown> = z.object({
   projectId: z.string(),
   createdAt: z.iso.datetime({ offset: true }).transform(v => new Date(v)),
   workspaceId: z.string(),
-})
+});
 
-export function eventFromJSON(jsonString: string): SafeParseResult<Event, SDKValidationError> {
+export function eventFromJSON(
+  jsonString: string,
+): SafeParseResult<Event, SDKValidationError> {
   return safeParse(
     jsonString,
-    x => Event$inboundSchema.parse(JSON.parse(x)),
+    (x) => Event$inboundSchema.parse(JSON.parse(x)),
     `Failed to parse 'Event' from JSON`,
-  )
+  );
 }