import * as z from "zod/v4";
import { ClosedEnum } from "../types/enums.js";
import { Result as SafeParseResult } from "../types/fp.js";
import { DeploymentCredentialRotationEvent } from "./deploymentcredentialrotationevent.js";
import { SDKValidationError } from "./errors/sdkvalidationerror.js";
export type EventDataDeploymentDeletionRequested = {
    /**
     * ID of the deployment
     */
    deploymentId: string;
    type: "DeploymentDeletionRequested";
};
/**
 * Type of authenticated principal that requested an event.
 */
export declare const EventKind4: {
    readonly User: "user";
    readonly ServiceAccount: "serviceAccount";
};
/**
 * Type of authenticated principal that requested an event.
 */
export type EventKind4 = ClosedEnum<typeof EventKind4>;
/**
 * Authenticated principal that requested a deployment intent event.
 */
export type EventActor4 = {
    /**
     * User email when the principal is a user.
     */
    email?: string | null | undefined;
    /**
     * Stable user or service-account identifier.
     */
    id: string;
    /**
     * Type of authenticated principal that requested an event.
     */
    kind: EventKind4;
};
export type EventActorUnion4 = EventActor4 | any;
export type EventDataDeploymentEnvironmentUpdated = {
    actor?: EventActor4 | any | null | undefined;
    /**
     * Names of the environment variables that changed (added, removed, or modified)
     */
    changedKeys: Array<string>;
    /**
     * ID of the deployment
     */
    deploymentId: string;
    type: "DeploymentEnvironmentUpdated";
};
export type EventDataDeploymentReleaseUnpinned = {
    /**
     * ID of the deployment
     */
    deploymentId: string;
    /**
     * ID of the release that was previously pinned
     */
    previousPinnedReleaseId: string;
    type: "DeploymentReleaseUnpinned";
};
export type EventDataDeploymentReleasePinned = {
    /**
     * ID of the deployment
     */
    deploymentId: string;
    /**
     * ID of the release that is now pinned
     */
    pinnedReleaseId: string;
    /**
     * ID of the previously pinned release, if any
     */
    previousPinnedReleaseId?: string | null | undefined;
    type: "DeploymentReleasePinned";
};
export type EventDataDeploymentRedeployRequested = {
    /**
     * ID of the deployment
     */
    deploymentId: string;
    /**
     * ID of the release being redeployed
     */
    releaseId: string;
    type: "DeploymentRedeployRequested";
};
/**
 * Type of authenticated principal that requested an event.
 */
export declare const EventKind3: {
    readonly User: "user";
    readonly ServiceAccount: "serviceAccount";
};
/**
 * Type of authenticated principal that requested an event.
 */
export type EventKind3 = ClosedEnum<typeof EventKind3>;
/**
 * Authenticated principal that requested a deployment intent event.
 */
export type EventActor3 = {
    /**
     * User email when the principal is a user.
     */
    email?: string | null | undefined;
    /**
     * Stable user or service-account identifier.
     */
    id: string;
    /**
     * Type of authenticated principal that requested an event.
     */
    kind: EventKind3;
};
export type EventActorUnion3 = EventActor3 | any;
/**
 * Canonical error container that provides a structured way to represent errors
 *
 * @remarks
 * with rich metadata including error codes, human-readable messages, context,
 * and chaining capabilities for error propagation.
 *
 * This struct is designed to be both machine-readable and user-friendly,
 * supporting serialization for API responses and detailed error reporting
 * in distributed systems.
 */
export type EventPreviousError = {
    /**
     * A unique identifier for the type of error.
     *
     * @remarks
     *
     * This should be a short, machine-readable string that can be used
     * by clients to programmatically handle different error types.
     * Examples: "NOT_FOUND", "VALIDATION_ERROR", "TIMEOUT"
     */
    code: string;
    /**
     * Additional diagnostic information about the error context.
     *
     * @remarks
     *
     * This optional field can contain structured data providing more details
     * about the error, such as validation errors, request parameters that
     * caused the issue, or other relevant context information.
     */
    context?: any | null | undefined;
    /**
     * Optional human-facing remediation hint.
     */
    hint?: string | null | undefined;
    /**
     * HTTP status code for this error.
     *
     * @remarks
     *
     * Used when converting the error to an HTTP response. If None, falls back to
     * the error type's default status code or 500.
     */
    httpStatusCode?: number | null | undefined;
    /**
     * Indicates if this is an internal error that should not be exposed to users.
     *
     * @remarks
     *
     * When `true`, this error contains sensitive information or implementation
     * details that should not be shown to end-users. Such errors should be
     * logged for debugging but replaced with generic error messages in responses.
     */
    internal: boolean;
    /**
     * Human-readable error message.
     *
     * @remarks
     *
     * This message should be clear and actionable for developers or end-users,
     * providing context about what went wrong and potentially how to fix it.
     */
    message: string;
    /**
     * Indicates whether the operation that caused the error should be retried.
     *
     * @remarks
     *
     * When `true`, the error is transient and the operation might succeed
     * if attempted again. When `false`, retrying the same operation is
     * unlikely to succeed without changes.
     */
    retryable: boolean;
    /**
     * 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 EventPreviousErrorUnion = EventPreviousError | any;
export type EventDataDeploymentRetryRequested = {
    actor?: EventActor3 | any | null | undefined;
    /**
     * ID of the release that the failed attempt was targeting, if known
     */
    attemptedReleaseId?: string | null | undefined;
    /**
     * ID of the deployment
     */
    deploymentId: string;
    previousError?: EventPreviousError | any | null | undefined;
    type: "DeploymentRetryRequested";
};
/**
 * Type of authenticated principal that requested an event.
 */
export declare const EventKind2: {
    readonly User: "user";
    readonly ServiceAccount: "serviceAccount";
};
/**
 * Type of authenticated principal that requested an event.
 */
export type EventKind2 = ClosedEnum<typeof EventKind2>;
/**
 * Authenticated principal that requested a deployment intent event.
 */
export type EventActor2 = {
    /**
     * User email when the principal is a user.
     */
    email?: string | null | undefined;
    /**
     * Stable user or service-account identifier.
     */
    id: string;
    /**
     * Type of authenticated principal that requested an event.
     */
    kind: EventKind2;
};
export type EventActorUnion2 = EventActor2 | any;
export type EventDataDeploymentReleaseChannelChanged = {
    actor?: EventActor2 | any | null | undefined;
    /**
     * Newly followed channel
     */
    channel: string;
    /**
     * ID of the deployment
     */
    deploymentId: string;
    /**
     * Previously followed channel
     */
    previousChannel: string;
    type: "DeploymentReleaseChannelChanged";
};
/**
 * Type of authenticated principal that requested an event.
 */
export declare const EventKind1: {
    readonly User: "user";
    readonly ServiceAccount: "serviceAccount";
};
/**
 * Type of authenticated principal that requested an event.
 */
export type EventKind1 = ClosedEnum<typeof EventKind1>;
/**
 * Authenticated principal that requested a deployment intent event.
 */
export type EventActor1 = {
    /**
     * User email when the principal is a user.
     */
    email?: string | null | undefined;
    /**
     * Stable user or service-account identifier.
     */
    id: string;
    /**
     * Type of authenticated principal that requested an event.
     */
    kind: EventKind1;
};
export type EventActorUnion1 = EventActor1 | any;
export type EventDataReleaseChannelUpdated = {
    actor?: EventActor1 | any | null | undefined;
    /**
     * Name of the channel that moved
     */
    channel: string;
    /**
     * ID of the release that was previously current, if any
     */
    previousReleaseId?: string | null | undefined;
    /**
     * ID of the release that is now current
     */
    releaseId: string;
    type: "ReleaseChannelUpdated";
};
export type EventDataDeploymentDeleted = {
    /**
     * ID of the deployment that was deleted
     */
    deploymentId: string;
    type: "DeploymentDeleted";
};
export type EventDataDeploymentRecovered = {
    /**
     * ID of the deployment
     */
    deploymentId: string;
    /**
     * ID of the release that is now live
     */
    releaseId: string;
    type: "DeploymentRecovered";
};
/**
 * Canonical error container that provides a structured way to represent errors
 *
 * @remarks
 * with rich metadata including error codes, human-readable messages, context,
 * and chaining capabilities for error propagation.
 *
 * This struct is designed to be both machine-readable and user-friendly,
 * supporting serialization for API responses and detailed error reporting
 * in distributed systems.
 */
export type EventDataError2 = {
    /**
     * A unique identifier for the type of error.
     *
     * @remarks
     *
     * This should be a short, machine-readable string that can be used
     * by clients to programmatically handle different error types.
     * Examples: "NOT_FOUND", "VALIDATION_ERROR", "TIMEOUT"
     */
    code: string;
    /**
     * Additional diagnostic information about the error context.
     *
     * @remarks
     *
     * This optional field can contain structured data providing more details
     * about the error, such as validation errors, request parameters that
     * caused the issue, or other relevant context information.
     */
    context?: any | null | undefined;
    /**
     * Optional human-facing remediation hint.
     */
    hint?: string | null | undefined;
    /**
     * HTTP status code for this error.
     *
     * @remarks
     *
     * Used when converting the error to an HTTP response. If None, falls back to
     * the error type's default status code or 500.
     */
    httpStatusCode?: number | null | undefined;
    /**
     * Indicates if this is an internal error that should not be exposed to users.
     *
     * @remarks
     *
     * When `true`, this error contains sensitive information or implementation
     * details that should not be shown to end-users. Such errors should be
     * logged for debugging but replaced with generic error messages in responses.
     */
    internal: boolean;
    /**
     * Human-readable error message.
     *
     * @remarks
     *
     * This message should be clear and actionable for developers or end-users,
     * providing context about what went wrong and potentially how to fix it.
     */
    message: string;
    /**
     * Indicates whether the operation that caused the error should be retried.
     *
     * @remarks
     *
     * When `true`, the error is transient and the operation might succeed
     * if attempted again. When `false`, retrying the same operation is
     * unlikely to succeed without changes.
     */
    retryable: boolean;
    /**
     * 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 EventDataDeploymentDegraded = {
    /**
     * ID of the deployment
     */
    deploymentId: string;
    /**
     * Canonical error container that provides a structured way to represent errors
     *
     * @remarks
     * with rich metadata including error codes, human-readable messages, context,
     * and chaining capabilities for error propagation.
     *
     * This struct is designed to be both machine-readable and user-friendly,
     * supporting serialization for API responses and detailed error reporting
     * in distributed systems.
     */
    error: EventDataError2;
    type: "DeploymentDegraded";
};
/**
 * Canonical error container that provides a structured way to represent errors
 *
 * @remarks
 * with rich metadata including error codes, human-readable messages, context,
 * and chaining capabilities for error propagation.
 *
 * This struct is designed to be both machine-readable and user-friendly,
 * supporting serialization for API responses and detailed error reporting
 * in distributed systems.
 */
export type EventDataError1 = {
    /**
     * A unique identifier for the type of error.
     *
     * @remarks
     *
     * This should be a short, machine-readable string that can be used
     * by clients to programmatically handle different error types.
     * Examples: "NOT_FOUND", "VALIDATION_ERROR", "TIMEOUT"
     */
    code: string;
    /**
     * Additional diagnostic information about the error context.
     *
     * @remarks
     *
     * This optional field can contain structured data providing more details
     * about the error, such as validation errors, request parameters that
     * caused the issue, or other relevant context information.
     */
    context?: any | null | undefined;
    /**
     * Optional human-facing remediation hint.
     */
    hint?: string | null | undefined;
    /**
     * HTTP status code for this error.
     *
     * @remarks
     *
     * Used when converting the error to an HTTP response. If None, falls back to
     * the error type's default status code or 500.
     */
    httpStatusCode?: number | null | undefined;
    /**
     * Indicates if this is an internal error that should not be exposed to users.
     *
     * @remarks
     *
     * When `true`, this error contains sensitive information or implementation
     * details that should not be shown to end-users. Such errors should be
     * logged for debugging but replaced with generic error messages in responses.
     */
    internal: boolean;
    /**
     * Human-readable error message.
     *
     * @remarks
     *
     * This message should be clear and actionable for developers or end-users,
     * providing context about what went wrong and potentially how to fix it.
     */
    message: string;
    /**
     * Indicates whether the operation that caused the error should be retried.
     *
     * @remarks
     *
     * When `true`, the error is transient and the operation might succeed
     * if attempted again. When `false`, retrying the same operation is
     * unlikely to succeed without changes.
     */
    retryable: boolean;
    /**
     * 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;
};
/**
 * Phase of a deployment at which a failure occurred.
 *
 * @remarks
 *
 * Derived from the source deployment status: `preflights-failed` →
 * `Preflights`, `provisioning-failed` → `Provisioning`, `update-failed` →
 * `Updating`, `delete-failed` → `Deleting`.
 * `refresh-failed` is modelled separately via `DeploymentDegraded`.
 */
export declare const EventPhase: {
    readonly Preflights: "preflights";
    readonly Provisioning: "provisioning";
    readonly Updating: "updating";
    readonly Deleting: "deleting";
};
/**
 * Phase of a deployment at which a failure occurred.
 *
 * @remarks
 *
 * Derived from the source deployment status: `preflights-failed` →
 * `Preflights`, `provisioning-failed` → `Provisioning`, `update-failed` →
 * `Updating`, `delete-failed` → `Deleting`.
 * `refresh-failed` is modelled separately via `DeploymentDegraded`.
 */
export type EventPhase = ClosedEnum<typeof EventPhase>;
export type EventDataDeploymentFailed = {
    /**
     * ID of the release the platform was trying to deploy, if known
     */
    attemptedReleaseId?: string | null | undefined;
    /**
     * ID of the deployment
     */
    deploymentId: string;
    /**
     * Canonical error container that provides a structured way to represent errors
     *
     * @remarks
     * with rich metadata including error codes, human-readable messages, context,
     * and chaining capabilities for error propagation.
     *
     * This struct is designed to be both machine-readable and user-friendly,
     * supporting serialization for API responses and detailed error reporting
     * in distributed systems.
     */
    error: EventDataError1;
    /**
     * Phase of a deployment at which a failure occurred.
     *
     * @remarks
     *
     * Derived from the source deployment status: `preflights-failed` →
     * `Preflights`, `provisioning-failed` → `Provisioning`, `update-failed` →
     * `Updating`, `delete-failed` → `Deleting`.
     * `refresh-failed` is modelled separately via `DeploymentDegraded`.
     */
    phase: EventPhase;
    type: "DeploymentFailed";
};
export type EventDataDeploymentReleased = {
    /**
     * ID of the deployment
     */
    deploymentId: string;
    /**
     * ID of the release that was previously live, if any
     */
    previousReleaseId?: string | null | undefined;
    /**
     * ID of the release that is now live
     */
    releaseId: string;
    type: "DeploymentReleased";
};
export type EventDataDeploymentCreated = {
    /**
     * ID of the deployment group this slot belongs to
     */
    deploymentGroupId: string;
    /**
     * ID of the deployment that was created
     */
    deploymentId: string;
    /**
     * Initial release the slot was created with, if any
     */
    releaseId?: string | null | undefined;
    type: "DeploymentCreated";
};
export type EventDataEmptyingBuckets = {
    /**
     * Names of the S3 buckets being emptied
     */
    bucketNames: Array<string>;
    type: "EmptyingBuckets";
};
export type EventDataDeletingCloudFormationStack = {
    /**
     * Name of the CloudFormation stack
     */
    cfnStackName: string;
    /**
     * Current stack status
     */
    currentStatus: string;
    type: "DeletingCloudFormationStack";
};
export type EventDataImportingStackStateFromCloudFormation = {
    /**
     * Name of the CloudFormation stack
     */
    cfnStackName: string;
    type: "ImportingStackStateFromCloudFormation";
};
export type EventDataAssumingRole = {
    /**
     * ARN of the role to assume
     */
    roleArn: string;
    type: "AssumingRole";
};
export type EventDataDeployingCloudFormationStack = {
    /**
     * Name of the CloudFormation stack
     */
    cfnStackName: string;
    /**
     * Current stack status
     */
    currentStatus: string;
    type: "DeployingCloudFormationStack";
};
export type EventDataEnsuringDockerRepository = {
    /**
     * Name of the docker repository
     */
    repositoryName: string;
    type: "EnsuringDockerRepository";
};
export type EventDataSettingUpPlatformContext = {
    /**
     * Name of the platform (e.g., "AWS", "GCP")
     */
    platformName: string;
    type: "SettingUpPlatformContext";
};
export type EventDataCleaningUpEnvironment = {
    /**
     * Name of the stack being cleaned up
     */
    stackName: string;
    /**
     * Name of the deployment strategy being used for cleanup
     */
    strategyName: string;
    type: "CleaningUpEnvironment";
};
export type EventDataCleaningUpStack = {
    /**
     * Name of the stack being cleaned up
     */
    stackName: string;
    /**
     * Name of the deployment strategy being used for cleanup
     */
    strategyName: string;
    type: "CleaningUpStack";
};
export type EventDataRunningTestWorker = {
    /**
     * Name of the stack being tested
     */
    stackName: string;
    type: "RunningTestWorker";
};
export type EventDataDeployingStack = {
    /**
     * Name of the stack being deployed
     */
    stackName: string;
    type: "DeployingStack";
};
export type EventDataPreparingEnvironment = {
    /**
     * Name of the deployment strategy being used
     */
    strategyName: string;
    type: "PreparingEnvironment";
};
export type EventDataDebuggingAgent = {
    /**
     * ID of the agent being debugged
     */
    agentId: string;
    /**
     * ID of the debug session
     */
    debugSessionId: string;
    type: "DebuggingAgent";
};
export type EventDataDeletingAgent = {
    /**
     * ID of the agent being deleted
     */
    agentId: string;
    /**
     * ID of the release that was running on the agent
     */
    releaseId: string;
    type: "DeletingAgent";
};
export type EventDataUpdatingAgent = {
    /**
     * ID of the agent being updated
     */
    agentId: string;
    /**
     * ID of the new release being deployed to the agent
     */
    releaseId: string;
    type: "UpdatingAgent";
};
export type EventDataProvisioningAgent = {
    /**
     * ID of the agent being provisioned
     */
    agentId: string;
    /**
     * ID of the release being deployed to the agent
     */
    releaseId: string;
    type: "ProvisioningAgent";
};
export type EventDataGeneratingTemplate = {
    /**
     * Platform for which the template is being generated
     */
    platform: string;
    type: "GeneratingTemplate";
};
export type EventDataGeneratingCloudFormationTemplate = {
    type: "GeneratingCloudFormationTemplate";
};
/**
 * Represents the target cloud platform.
 */
export declare const EventPlatform: {
    readonly Aws: "aws";
    readonly Gcp: "gcp";
    readonly Azure: "azure";
    readonly Kubernetes: "kubernetes";
    readonly Machines: "machines";
    readonly Local: "local";
    readonly Test: "test";
};
/**
 * Represents the target cloud platform.
 */
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.
 */
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;
    /**
     * 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;
};
/**
 * Represents the target cloud platform.
 */
export declare const EventControllerPlatformEnum: {
    readonly Aws: "aws";
    readonly Gcp: "gcp";
    readonly Azure: "azure";
    readonly Kubernetes: "kubernetes";
    readonly Machines: "machines";
    readonly Local: "local";
    readonly Test: "test";
};
/**
 * Represents the target cloud platform.
 */
export type EventControllerPlatformEnum = ClosedEnum<typeof EventControllerPlatformEnum>;
export type EventControllerPlatformUnion = EventControllerPlatformEnum | any;
/**
 * Reference to a resource by its stable id and resource type.
 */
export type EventDependency = {
    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;
};
/**
 * Canonical error container that provides a structured way to represent errors
 *
 * @remarks
 * with rich metadata including error codes, human-readable messages, context,
 * and chaining capabilities for error propagation.
 *
 * This struct is designed to be both machine-readable and user-friendly,
 * supporting serialization for API responses and detailed error reporting
 * in distributed systems.
 */
export type EventErrorNextState = {
    /**
     * A unique identifier for the type of error.
     *
     * @remarks
     *
     * This should be a short, machine-readable string that can be used
     * by clients to programmatically handle different error types.
     * Examples: "NOT_FOUND", "VALIDATION_ERROR", "TIMEOUT"
     */
    code: string;
    /**
     * Additional diagnostic information about the error context.
     *
     * @remarks
     *
     * This optional field can contain structured data providing more details
     * about the error, such as validation errors, request parameters that
     * caused the issue, or other relevant context information.
     */
    context?: any | null | undefined;
    /**
     * Optional human-facing remediation hint.
     */
    hint?: string | null | undefined;
    /**
     * HTTP status code for this error.
     *
     * @remarks
     *
     * Used when converting the error to an HTTP response. If None, falls back to
     * the error type's default status code or 500.
     */
    httpStatusCode?: number | null | undefined;
    /**
     * Indicates if this is an internal error that should not be exposed to users.
     *
     * @remarks
     *
     * When `true`, this error contains sensitive information or implementation
     * details that should not be shown to end-users. Such errors should be
     * logged for debugging but replaced with generic error messages in responses.
     */
    internal: boolean;
    /**
     * Human-readable error message.
     *
     * @remarks
     *
     * This message should be clear and actionable for developers or end-users,
     * providing context about what went wrong and potentially how to fix it.
     */
    message: string;
    /**
     * Indicates whether the operation that caused the error should be retried.
     *
     * @remarks
     *
     * When `true`, the error is transient and the operation might succeed
     * if attempted again. When `false`, retrying the same operation is
     * unlikely to succeed without changes.
     */
    retryable: boolean;
    /**
     * 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 EventNextStateErrorUnion = EventErrorNextState | any;
/**
 * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
 */
export declare const EventLifecycleEnum: {
    readonly Frozen: "frozen";
    readonly Live: "live";
};
/**
 * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
 */
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.
 */
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;
};
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.
 */
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;
    /**
     * 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;
};
export type EventPreviousConfigUnion = EventPreviousConfig | any;
/**
 * Represents the high-level status of a resource during its lifecycle.
 */
export declare const EventStatus: {
    readonly Pending: "pending";
    readonly Provisioning: "provisioning";
    readonly ProvisionFailed: "provision-failed";
    readonly Running: "running";
    readonly Updating: "updating";
    readonly UpdateFailed: "update-failed";
    readonly Deleting: "deleting";
    readonly DeleteFailed: "delete-failed";
    readonly TeardownRequired: "teardown-required";
    readonly Deleted: "deleted";
    readonly RefreshFailed: "refresh-failed";
};
/**
 * Represents the high-level status of a resource during its lifecycle.
 */
export type EventStatus = ClosedEnum<typeof EventStatus>;
/**
 * Represents the state of a single resource within the stack for a specific platform.
 */
export type EventResources = {
    /**
     * 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;
    controllerPlatform?: EventControllerPlatformEnum | any | null | undefined;
    /**
     * 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?: EventErrorNextState | any | null | 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;
    /**
     * Represents the high-level status of a resource during its lifecycle.
     */
    status: EventStatus;
    /**
     * The high-level type of the resource (e.g., Worker::RESOURCE_TYPE, Storage::RESOURCE_TYPE).
     */
    type: string;
};
/**
 * Represents the collective state of all resources in a stack, including platform and pending actions.
 */
export type EventNextState = {
    /**
     * Represents the target cloud platform.
     */
    platform: EventPlatform;
    /**
     * A prefix used for resource naming to ensure uniqueness across deployments.
     */
    resourcePrefix: string;
    /**
     * The state of individual resources, keyed by resource ID.
     */
    resources: {
        [k: string]: EventResources;
    };
};
export type EventDataStackStep = {
    /**
     * Represents the collective state of all resources in a stack, including platform and pending actions.
     */
    nextState: EventNextState;
    /**
     * An suggested duration to wait before executing the next step.
     */
    suggestedDelayMs?: number | null | undefined;
    type: "StackStep";
};
export type EventDataCompilingCode = {
    /**
     * Language being compiled (rust, typescript, etc.)
     */
    language: string;
    /**
     * Current progress/status line from the build output
     */
    progress?: string | null | undefined;
    type: "CompilingCode";
};
export type EventDataCreatingRelease = {
    /**
     * Project name
     */
    project: string;
    type: "CreatingRelease";
};
export type EventDataPushingResource = {
    /**
     * Name of the resource being pushed
     */
    resourceName: string;
    /**
     * Type of the resource: "worker", "container"
     */
    resourceType: string;
    type: "PushingResource";
};
export type EventDataPushingStack = {
    /**
     * Human-readable destination for pushed images
     */
    destination?: string | null | undefined;
    /**
     * Target platform
     */
    platform: string;
    /**
     * Name of the stack being pushed
     */
    stack: string;
    type: "PushingStack";
};
/**
 * Progress information for image push operations
 */
export type EventProgress = {
    /**
     * Bytes uploaded so far
     */
    bytesUploaded: number;
    /**
     * Number of layers uploaded so far
     */
    layersUploaded: number;
    /**
     * Current operation being performed
     */
    operation: string;
    /**
     * Total bytes to upload
     */
    totalBytes: number;
    /**
     * Total number of layers to upload
     */
    totalLayers: number;
};
export type EventProgressUnion = EventProgress | any;
export type EventDataPushingImage = {
    /**
     * Name of the image being pushed
     */
    image: string;
    progress?: EventProgress | any | null | undefined;
    type: "PushingImage";
};
export type EventDataBuildingImage = {
    /**
     * Name of the image being built
     */
    image: string;
    type: "BuildingImage";
};
export type EventDataBuildingResource = {
    /**
     * All resource names sharing this build (for deduped container groups)
     */
    relatedResources?: Array<string> | undefined;
    /**
     * Name of the resource being built
     */
    resourceName: string;
    /**
     * Type of the resource: "worker", "container"
     */
    resourceType: string;
    type: "BuildingResource";
};
export type EventDataDownloadingAlienRuntime = {
    /**
     * Target triple for the runtime
     */
    targetTriple: string;
    type: "DownloadingAlienRuntime";
    /**
     * URL being downloaded from
     */
    url: string;
};
export type EventDataRunningPreflights = {
    /**
     * Platform being targeted
     */
    platform: string;
    /**
     * Name of the stack being checked
     */
    stack: string;
    type: "RunningPreflights";
};
export type EventDataBuildingStack = {
    /**
     * Name of the stack being built
     */
    stack: string;
    type: "BuildingStack";
};
export type EventDataFinished = {
    type: "Finished";
};
export type EventDataLoadingConfiguration = {
    type: "LoadingConfiguration";
};
export type EventDataUnion = EventDataLoadingConfiguration | EventDataFinished | EventDataBuildingStack | EventDataRunningPreflights | EventDataDownloadingAlienRuntime | EventDataBuildingResource | EventDataBuildingImage | EventDataPushingImage | EventDataPushingStack | EventDataPushingResource | EventDataCreatingRelease | EventDataCompilingCode | EventDataStackStep | EventDataGeneratingCloudFormationTemplate | EventDataGeneratingTemplate | EventDataProvisioningAgent | EventDataUpdatingAgent | EventDataDeletingAgent | EventDataDebuggingAgent | EventDataPreparingEnvironment | EventDataDeployingStack | EventDataRunningTestWorker | EventDataCleaningUpStack | EventDataCleaningUpEnvironment | EventDataSettingUpPlatformContext | EventDataEnsuringDockerRepository | EventDataDeployingCloudFormationStack | EventDataAssumingRole | EventDataImportingStackStateFromCloudFormation | EventDataDeletingCloudFormationStack | EventDataEmptyingBuckets | EventDataDeploymentCreated | EventDataDeploymentReleased | EventDataDeploymentFailed | EventDataDeploymentDegraded | EventDataDeploymentRecovered | EventDataDeploymentDeleted | EventDataReleaseChannelUpdated | EventDataDeploymentReleaseChannelChanged | EventDataDeploymentRetryRequested | EventDataDeploymentRedeployRequested | EventDataDeploymentReleasePinned | EventDataDeploymentReleaseUnpinned | EventDataDeploymentEnvironmentUpdated | EventDataDeploymentDeletionRequested | DeploymentCredentialRotationEvent;
export declare const EventStateSuccess: {
    readonly Success: "success";
};
export type EventStateSuccess = ClosedEnum<typeof EventStateSuccess>;
export declare const EventStateStarted: {
    readonly Started: "started";
};
export type EventStateStarted = ClosedEnum<typeof EventStateStarted>;
export declare const EventStateNone: {
    readonly None: "none";
};
export type EventStateNone = ClosedEnum<typeof EventStateNone>;
/**
 * Canonical error container that provides a structured way to represent errors
 *
 * @remarks
 * with rich metadata including error codes, human-readable messages, context,
 * and chaining capabilities for error propagation.
 *
 * This struct is designed to be both machine-readable and user-friendly,
 * supporting serialization for API responses and detailed error reporting
 * in distributed systems.
 */
export type EventStateError = {
    /**
     * A unique identifier for the type of error.
     *
     * @remarks
     *
     * This should be a short, machine-readable string that can be used
     * by clients to programmatically handle different error types.
     * Examples: "NOT_FOUND", "VALIDATION_ERROR", "TIMEOUT"
     */
    code: string;
    /**
     * Additional diagnostic information about the error context.
     *
     * @remarks
     *
     * This optional field can contain structured data providing more details
     * about the error, such as validation errors, request parameters that
     * caused the issue, or other relevant context information.
     */
    context?: any | null | undefined;
    /**
     * Optional human-facing remediation hint.
     */
    hint?: string | null | undefined;
    /**
     * HTTP status code for this error.
     *
     * @remarks
     *
     * Used when converting the error to an HTTP response. If None, falls back to
     * the error type's default status code or 500.
     */
    httpStatusCode?: number | null | undefined;
    /**
     * Indicates if this is an internal error that should not be exposed to users.
     *
     * @remarks
     *
     * When `true`, this error contains sensitive information or implementation
     * details that should not be shown to end-users. Such errors should be
     * logged for debugging but replaced with generic error messages in responses.
     */
    internal: boolean;
    /**
     * Human-readable error message.
     *
     * @remarks
     *
     * This message should be clear and actionable for developers or end-users,
     * providing context about what went wrong and potentially how to fix it.
     */
    message: string;
    /**
     * Indicates whether the operation that caused the error should be retried.
     *
     * @remarks
     *
     * When `true`, the error is transient and the operation might succeed
     * if attempted again. When `false`, retrying the same operation is
     * unlikely to succeed without changes.
     */
    retryable: boolean;
    /**
     * 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 EventStateErrorUnion = EventStateError | any;
/**
 * Event failed with an error
 */
export type EventFailed = {
    error?: EventStateError | any | null | undefined;
};
export type EventState = {
    /**
     * Event failed with an error
     */
    failed: EventFailed;
};
/**
 * Represents the state of an event
 */
export type EventStateUnion = EventState | EventStateNone | EventStateStarted | EventStateSuccess;
export type Event = {
    /**
     * Unique identifier for the event.
     */
    id: string;
    /**
     * Unique identifier for the deployment.
     */
    deploymentId?: string | null | undefined;
    /**
     * Unique identifier for the release.
     */
    releaseId?: string | null | undefined;
    /**
     * Unique identifier for the debug session.
     */
    debugSessionId?: string | null | undefined;
    data: EventDataLoadingConfiguration | EventDataFinished | EventDataBuildingStack | EventDataRunningPreflights | EventDataDownloadingAlienRuntime | EventDataBuildingResource | EventDataBuildingImage | EventDataPushingImage | EventDataPushingStack | EventDataPushingResource | EventDataCreatingRelease | EventDataCompilingCode | EventDataStackStep | EventDataGeneratingCloudFormationTemplate | EventDataGeneratingTemplate | EventDataProvisioningAgent | EventDataUpdatingAgent | EventDataDeletingAgent | EventDataDebuggingAgent | EventDataPreparingEnvironment | EventDataDeployingStack | EventDataRunningTestWorker | EventDataCleaningUpStack | EventDataCleaningUpEnvironment | EventDataSettingUpPlatformContext | EventDataEnsuringDockerRepository | EventDataDeployingCloudFormationStack | EventDataAssumingRole | EventDataImportingStackStateFromCloudFormation | EventDataDeletingCloudFormationStack | EventDataEmptyingBuckets | EventDataDeploymentCreated | EventDataDeploymentReleased | EventDataDeploymentFailed | EventDataDeploymentDegraded | EventDataDeploymentRecovered | EventDataDeploymentDeleted | EventDataReleaseChannelUpdated | EventDataDeploymentReleaseChannelChanged | EventDataDeploymentRetryRequested | EventDataDeploymentRedeployRequested | EventDataDeploymentReleasePinned | EventDataDeploymentReleaseUnpinned | EventDataDeploymentEnvironmentUpdated | EventDataDeploymentDeletionRequested | DeploymentCredentialRotationEvent;
    /**
     * Represents the state of an event
     */
    state: EventState | EventStateNone | EventStateStarted | EventStateSuccess;
    /**
     * Unique identifier for the project.
     */
    projectId: string;
    createdAt: Date;
    /**
     * Unique identifier for the workspace.
     */
    workspaceId: string;
};
/** @internal */
export declare const EventDataDeploymentDeletionRequested$inboundSchema: z.ZodType<EventDataDeploymentDeletionRequested, unknown>;
export declare function eventDataDeploymentDeletionRequestedFromJSON(jsonString: string): SafeParseResult<EventDataDeploymentDeletionRequested, SDKValidationError>;
/** @internal */
export declare const EventKind4$inboundSchema: z.ZodEnum<typeof EventKind4>;
/** @internal */
export declare const EventActor4$inboundSchema: z.ZodType<EventActor4, unknown>;
export declare function eventActor4FromJSON(jsonString: string): SafeParseResult<EventActor4, SDKValidationError>;
/** @internal */
export declare const EventActorUnion4$inboundSchema: z.ZodType<EventActorUnion4, unknown>;
export declare function eventActorUnion4FromJSON(jsonString: string): SafeParseResult<EventActorUnion4, SDKValidationError>;
/** @internal */
export declare const EventDataDeploymentEnvironmentUpdated$inboundSchema: z.ZodType<EventDataDeploymentEnvironmentUpdated, unknown>;
export declare function eventDataDeploymentEnvironmentUpdatedFromJSON(jsonString: string): SafeParseResult<EventDataDeploymentEnvironmentUpdated, SDKValidationError>;
/** @internal */
export declare const EventDataDeploymentReleaseUnpinned$inboundSchema: z.ZodType<EventDataDeploymentReleaseUnpinned, unknown>;
export declare function eventDataDeploymentReleaseUnpinnedFromJSON(jsonString: string): SafeParseResult<EventDataDeploymentReleaseUnpinned, SDKValidationError>;
/** @internal */
export declare const EventDataDeploymentReleasePinned$inboundSchema: z.ZodType<EventDataDeploymentReleasePinned, unknown>;
export declare function eventDataDeploymentReleasePinnedFromJSON(jsonString: string): SafeParseResult<EventDataDeploymentReleasePinned, SDKValidationError>;
/** @internal */
export declare const EventDataDeploymentRedeployRequested$inboundSchema: z.ZodType<EventDataDeploymentRedeployRequested, unknown>;
export declare function eventDataDeploymentRedeployRequestedFromJSON(jsonString: string): SafeParseResult<EventDataDeploymentRedeployRequested, SDKValidationError>;
/** @internal */
export declare const EventKind3$inboundSchema: z.ZodEnum<typeof EventKind3>;
/** @internal */
export declare const EventActor3$inboundSchema: z.ZodType<EventActor3, unknown>;
export declare function eventActor3FromJSON(jsonString: string): SafeParseResult<EventActor3, SDKValidationError>;
/** @internal */
export declare const EventActorUnion3$inboundSchema: z.ZodType<EventActorUnion3, unknown>;
export declare function eventActorUnion3FromJSON(jsonString: string): SafeParseResult<EventActorUnion3, SDKValidationError>;
/** @internal */
export declare const EventPreviousError$inboundSchema: z.ZodType<EventPreviousError, unknown>;
export declare function eventPreviousErrorFromJSON(jsonString: string): SafeParseResult<EventPreviousError, SDKValidationError>;
/** @internal */
export declare const EventPreviousErrorUnion$inboundSchema: z.ZodType<EventPreviousErrorUnion, unknown>;
export declare function eventPreviousErrorUnionFromJSON(jsonString: string): SafeParseResult<EventPreviousErrorUnion, SDKValidationError>;
/** @internal */
export declare const EventDataDeploymentRetryRequested$inboundSchema: z.ZodType<EventDataDeploymentRetryRequested, unknown>;
export declare function eventDataDeploymentRetryRequestedFromJSON(jsonString: string): SafeParseResult<EventDataDeploymentRetryRequested, SDKValidationError>;
/** @internal */
export declare const EventKind2$inboundSchema: z.ZodEnum<typeof EventKind2>;
/** @internal */
export declare const EventActor2$inboundSchema: z.ZodType<EventActor2, unknown>;
export declare function eventActor2FromJSON(jsonString: string): SafeParseResult<EventActor2, SDKValidationError>;
/** @internal */
export declare const EventActorUnion2$inboundSchema: z.ZodType<EventActorUnion2, unknown>;
export declare function eventActorUnion2FromJSON(jsonString: string): SafeParseResult<EventActorUnion2, SDKValidationError>;
/** @internal */
export declare const EventDataDeploymentReleaseChannelChanged$inboundSchema: z.ZodType<EventDataDeploymentReleaseChannelChanged, unknown>;
export declare function eventDataDeploymentReleaseChannelChangedFromJSON(jsonString: string): SafeParseResult<EventDataDeploymentReleaseChannelChanged, SDKValidationError>;
/** @internal */
export declare const EventKind1$inboundSchema: z.ZodEnum<typeof EventKind1>;
/** @internal */
export declare const EventActor1$inboundSchema: z.ZodType<EventActor1, unknown>;
export declare function eventActor1FromJSON(jsonString: string): SafeParseResult<EventActor1, SDKValidationError>;
/** @internal */
export declare const EventActorUnion1$inboundSchema: z.ZodType<EventActorUnion1, unknown>;
export declare function eventActorUnion1FromJSON(jsonString: string): SafeParseResult<EventActorUnion1, SDKValidationError>;
/** @internal */
export declare const EventDataReleaseChannelUpdated$inboundSchema: z.ZodType<EventDataReleaseChannelUpdated, unknown>;
export declare function eventDataReleaseChannelUpdatedFromJSON(jsonString: string): SafeParseResult<EventDataReleaseChannelUpdated, SDKValidationError>;
/** @internal */
export declare const EventDataDeploymentDeleted$inboundSchema: z.ZodType<EventDataDeploymentDeleted, unknown>;
export declare function eventDataDeploymentDeletedFromJSON(jsonString: string): SafeParseResult<EventDataDeploymentDeleted, SDKValidationError>;
/** @internal */
export declare const EventDataDeploymentRecovered$inboundSchema: z.ZodType<EventDataDeploymentRecovered, unknown>;
export declare function eventDataDeploymentRecoveredFromJSON(jsonString: string): SafeParseResult<EventDataDeploymentRecovered, SDKValidationError>;
/** @internal */
export declare const EventDataError2$inboundSchema: z.ZodType<EventDataError2, unknown>;
export declare function eventDataError2FromJSON(jsonString: string): SafeParseResult<EventDataError2, SDKValidationError>;
/** @internal */
export declare const EventDataDeploymentDegraded$inboundSchema: z.ZodType<EventDataDeploymentDegraded, unknown>;
export declare function eventDataDeploymentDegradedFromJSON(jsonString: string): SafeParseResult<EventDataDeploymentDegraded, SDKValidationError>;
/** @internal */
export declare const EventDataError1$inboundSchema: z.ZodType<EventDataError1, unknown>;
export declare function eventDataError1FromJSON(jsonString: string): SafeParseResult<EventDataError1, SDKValidationError>;
/** @internal */
export declare const EventPhase$inboundSchema: z.ZodEnum<typeof EventPhase>;
/** @internal */
export declare const EventDataDeploymentFailed$inboundSchema: z.ZodType<EventDataDeploymentFailed, unknown>;
export declare function eventDataDeploymentFailedFromJSON(jsonString: string): SafeParseResult<EventDataDeploymentFailed, SDKValidationError>;
/** @internal */
export declare const EventDataDeploymentReleased$inboundSchema: z.ZodType<EventDataDeploymentReleased, unknown>;
export declare function eventDataDeploymentReleasedFromJSON(jsonString: string): SafeParseResult<EventDataDeploymentReleased, SDKValidationError>;
/** @internal */
export declare const EventDataDeploymentCreated$inboundSchema: z.ZodType<EventDataDeploymentCreated, unknown>;
export declare function eventDataDeploymentCreatedFromJSON(jsonString: string): SafeParseResult<EventDataDeploymentCreated, SDKValidationError>;
/** @internal */
export declare const EventDataEmptyingBuckets$inboundSchema: z.ZodType<EventDataEmptyingBuckets, unknown>;
export declare function eventDataEmptyingBucketsFromJSON(jsonString: string): SafeParseResult<EventDataEmptyingBuckets, SDKValidationError>;
/** @internal */
export declare const EventDataDeletingCloudFormationStack$inboundSchema: z.ZodType<EventDataDeletingCloudFormationStack, unknown>;
export declare function eventDataDeletingCloudFormationStackFromJSON(jsonString: string): SafeParseResult<EventDataDeletingCloudFormationStack, SDKValidationError>;
/** @internal */
export declare const EventDataImportingStackStateFromCloudFormation$inboundSchema: z.ZodType<EventDataImportingStackStateFromCloudFormation, unknown>;
export declare function eventDataImportingStackStateFromCloudFormationFromJSON(jsonString: string): SafeParseResult<EventDataImportingStackStateFromCloudFormation, SDKValidationError>;
/** @internal */
export declare const EventDataAssumingRole$inboundSchema: z.ZodType<EventDataAssumingRole, unknown>;
export declare function eventDataAssumingRoleFromJSON(jsonString: string): SafeParseResult<EventDataAssumingRole, SDKValidationError>;
/** @internal */
export declare const EventDataDeployingCloudFormationStack$inboundSchema: z.ZodType<EventDataDeployingCloudFormationStack, unknown>;
export declare function eventDataDeployingCloudFormationStackFromJSON(jsonString: string): SafeParseResult<EventDataDeployingCloudFormationStack, SDKValidationError>;
/** @internal */
export declare const EventDataEnsuringDockerRepository$inboundSchema: z.ZodType<EventDataEnsuringDockerRepository, unknown>;
export declare function eventDataEnsuringDockerRepositoryFromJSON(jsonString: string): SafeParseResult<EventDataEnsuringDockerRepository, SDKValidationError>;
/** @internal */
export declare const EventDataSettingUpPlatformContext$inboundSchema: z.ZodType<EventDataSettingUpPlatformContext, unknown>;
export declare function eventDataSettingUpPlatformContextFromJSON(jsonString: string): SafeParseResult<EventDataSettingUpPlatformContext, SDKValidationError>;
/** @internal */
export declare const EventDataCleaningUpEnvironment$inboundSchema: z.ZodType<EventDataCleaningUpEnvironment, unknown>;
export declare function eventDataCleaningUpEnvironmentFromJSON(jsonString: string): SafeParseResult<EventDataCleaningUpEnvironment, SDKValidationError>;
/** @internal */
export declare const EventDataCleaningUpStack$inboundSchema: z.ZodType<EventDataCleaningUpStack, unknown>;
export declare function eventDataCleaningUpStackFromJSON(jsonString: string): SafeParseResult<EventDataCleaningUpStack, SDKValidationError>;
/** @internal */
export declare const EventDataRunningTestWorker$inboundSchema: z.ZodType<EventDataRunningTestWorker, unknown>;
export declare function eventDataRunningTestWorkerFromJSON(jsonString: string): SafeParseResult<EventDataRunningTestWorker, SDKValidationError>;
/** @internal */
export declare const EventDataDeployingStack$inboundSchema: z.ZodType<EventDataDeployingStack, unknown>;
export declare function eventDataDeployingStackFromJSON(jsonString: string): SafeParseResult<EventDataDeployingStack, SDKValidationError>;
/** @internal */
export declare const EventDataPreparingEnvironment$inboundSchema: z.ZodType<EventDataPreparingEnvironment, unknown>;
export declare function eventDataPreparingEnvironmentFromJSON(jsonString: string): SafeParseResult<EventDataPreparingEnvironment, SDKValidationError>;
/** @internal */
export declare const EventDataDebuggingAgent$inboundSchema: z.ZodType<EventDataDebuggingAgent, unknown>;
export declare function eventDataDebuggingAgentFromJSON(jsonString: string): SafeParseResult<EventDataDebuggingAgent, SDKValidationError>;
/** @internal */
export declare const EventDataDeletingAgent$inboundSchema: z.ZodType<EventDataDeletingAgent, unknown>;
export declare function eventDataDeletingAgentFromJSON(jsonString: string): SafeParseResult<EventDataDeletingAgent, SDKValidationError>;
/** @internal */
export declare const EventDataUpdatingAgent$inboundSchema: z.ZodType<EventDataUpdatingAgent, unknown>;
export declare function eventDataUpdatingAgentFromJSON(jsonString: string): SafeParseResult<EventDataUpdatingAgent, SDKValidationError>;
/** @internal */
export declare const EventDataProvisioningAgent$inboundSchema: z.ZodType<EventDataProvisioningAgent, unknown>;
export declare function eventDataProvisioningAgentFromJSON(jsonString: string): SafeParseResult<EventDataProvisioningAgent, SDKValidationError>;
/** @internal */
export declare const EventDataGeneratingTemplate$inboundSchema: z.ZodType<EventDataGeneratingTemplate, unknown>;
export declare function eventDataGeneratingTemplateFromJSON(jsonString: string): SafeParseResult<EventDataGeneratingTemplate, SDKValidationError>;
/** @internal */
export declare const EventDataGeneratingCloudFormationTemplate$inboundSchema: z.ZodType<EventDataGeneratingCloudFormationTemplate, unknown>;
export declare function eventDataGeneratingCloudFormationTemplateFromJSON(jsonString: string): SafeParseResult<EventDataGeneratingCloudFormationTemplate, SDKValidationError>;
/** @internal */
export declare const EventPlatform$inboundSchema: z.ZodEnum<typeof EventPlatform>;
/** @internal */
export declare const EventConfig$inboundSchema: z.ZodType<EventConfig, unknown>;
export declare function eventConfigFromJSON(jsonString: string): SafeParseResult<EventConfig, SDKValidationError>;
/** @internal */
export declare const EventControllerPlatformEnum$inboundSchema: z.ZodEnum<typeof EventControllerPlatformEnum>;
/** @internal */
export declare const EventControllerPlatformUnion$inboundSchema: z.ZodType<EventControllerPlatformUnion, unknown>;
export declare function eventControllerPlatformUnionFromJSON(jsonString: string): SafeParseResult<EventControllerPlatformUnion, SDKValidationError>;
/** @internal */
export declare const EventDependency$inboundSchema: z.ZodType<EventDependency, unknown>;
export declare function eventDependencyFromJSON(jsonString: string): SafeParseResult<EventDependency, SDKValidationError>;
/** @internal */
export declare const EventErrorNextState$inboundSchema: z.ZodType<EventErrorNextState, unknown>;
export declare function eventErrorNextStateFromJSON(jsonString: string): SafeParseResult<EventErrorNextState, SDKValidationError>;
/** @internal */
export declare const EventNextStateErrorUnion$inboundSchema: z.ZodType<EventNextStateErrorUnion, unknown>;
export declare function eventNextStateErrorUnionFromJSON(jsonString: string): SafeParseResult<EventNextStateErrorUnion, SDKValidationError>;
/** @internal */
export declare const EventLifecycleEnum$inboundSchema: z.ZodEnum<typeof EventLifecycleEnum>;
/** @internal */
export declare const EventLifecycleUnion$inboundSchema: z.ZodType<EventLifecycleUnion, unknown>;
export declare function eventLifecycleUnionFromJSON(jsonString: string): SafeParseResult<EventLifecycleUnion, SDKValidationError>;
/** @internal */
export declare const EventOutputs$inboundSchema: z.ZodType<EventOutputs, unknown>;
export declare function eventOutputsFromJSON(jsonString: string): SafeParseResult<EventOutputs, SDKValidationError>;
/** @internal */
export declare const EventOutputsUnion$inboundSchema: z.ZodType<EventOutputsUnion, unknown>;
export declare function eventOutputsUnionFromJSON(jsonString: string): SafeParseResult<EventOutputsUnion, SDKValidationError>;
/** @internal */
export declare const EventPreviousConfig$inboundSchema: z.ZodType<EventPreviousConfig, unknown>;
export declare function eventPreviousConfigFromJSON(jsonString: string): SafeParseResult<EventPreviousConfig, SDKValidationError>;
/** @internal */
export declare const EventPreviousConfigUnion$inboundSchema: z.ZodType<EventPreviousConfigUnion, unknown>;
export declare function eventPreviousConfigUnionFromJSON(jsonString: string): SafeParseResult<EventPreviousConfigUnion, SDKValidationError>;
/** @internal */
export declare const EventStatus$inboundSchema: z.ZodEnum<typeof EventStatus>;
/** @internal */
export declare const EventResources$inboundSchema: z.ZodType<EventResources, unknown>;
export declare function eventResourcesFromJSON(jsonString: string): SafeParseResult<EventResources, SDKValidationError>;
/** @internal */
export declare const EventNextState$inboundSchema: z.ZodType<EventNextState, unknown>;
export declare function eventNextStateFromJSON(jsonString: string): SafeParseResult<EventNextState, SDKValidationError>;
/** @internal */
export declare const EventDataStackStep$inboundSchema: z.ZodType<EventDataStackStep, unknown>;
export declare function eventDataStackStepFromJSON(jsonString: string): SafeParseResult<EventDataStackStep, SDKValidationError>;
/** @internal */
export declare const EventDataCompilingCode$inboundSchema: z.ZodType<EventDataCompilingCode, unknown>;
export declare function eventDataCompilingCodeFromJSON(jsonString: string): SafeParseResult<EventDataCompilingCode, SDKValidationError>;
/** @internal */
export declare const EventDataCreatingRelease$inboundSchema: z.ZodType<EventDataCreatingRelease, unknown>;
export declare function eventDataCreatingReleaseFromJSON(jsonString: string): SafeParseResult<EventDataCreatingRelease, SDKValidationError>;
/** @internal */
export declare const EventDataPushingResource$inboundSchema: z.ZodType<EventDataPushingResource, unknown>;
export declare function eventDataPushingResourceFromJSON(jsonString: string): SafeParseResult<EventDataPushingResource, SDKValidationError>;
/** @internal */
export declare const EventDataPushingStack$inboundSchema: z.ZodType<EventDataPushingStack, unknown>;
export declare function eventDataPushingStackFromJSON(jsonString: string): SafeParseResult<EventDataPushingStack, SDKValidationError>;
/** @internal */
export declare const EventProgress$inboundSchema: z.ZodType<EventProgress, unknown>;
export declare function eventProgressFromJSON(jsonString: string): SafeParseResult<EventProgress, SDKValidationError>;
/** @internal */
export declare const EventProgressUnion$inboundSchema: z.ZodType<EventProgressUnion, unknown>;
export declare function eventProgressUnionFromJSON(jsonString: string): SafeParseResult<EventProgressUnion, SDKValidationError>;
/** @internal */
export declare const EventDataPushingImage$inboundSchema: z.ZodType<EventDataPushingImage, unknown>;
export declare function eventDataPushingImageFromJSON(jsonString: string): SafeParseResult<EventDataPushingImage, SDKValidationError>;
/** @internal */
export declare const EventDataBuildingImage$inboundSchema: z.ZodType<EventDataBuildingImage, unknown>;
export declare function eventDataBuildingImageFromJSON(jsonString: string): SafeParseResult<EventDataBuildingImage, SDKValidationError>;
/** @internal */
export declare const EventDataBuildingResource$inboundSchema: z.ZodType<EventDataBuildingResource, unknown>;
export declare function eventDataBuildingResourceFromJSON(jsonString: string): SafeParseResult<EventDataBuildingResource, SDKValidationError>;
/** @internal */
export declare const EventDataDownloadingAlienRuntime$inboundSchema: z.ZodType<EventDataDownloadingAlienRuntime, unknown>;
export declare function eventDataDownloadingAlienRuntimeFromJSON(jsonString: string): SafeParseResult<EventDataDownloadingAlienRuntime, SDKValidationError>;
/** @internal */
export declare const EventDataRunningPreflights$inboundSchema: z.ZodType<EventDataRunningPreflights, unknown>;
export declare function eventDataRunningPreflightsFromJSON(jsonString: string): SafeParseResult<EventDataRunningPreflights, SDKValidationError>;
/** @internal */
export declare const EventDataBuildingStack$inboundSchema: z.ZodType<EventDataBuildingStack, unknown>;
export declare function eventDataBuildingStackFromJSON(jsonString: string): SafeParseResult<EventDataBuildingStack, SDKValidationError>;
/** @internal */
export declare const EventDataFinished$inboundSchema: z.ZodType<EventDataFinished, unknown>;
export declare function eventDataFinishedFromJSON(jsonString: string): SafeParseResult<EventDataFinished, SDKValidationError>;
/** @internal */
export declare const EventDataLoadingConfiguration$inboundSchema: z.ZodType<EventDataLoadingConfiguration, unknown>;
export declare function eventDataLoadingConfigurationFromJSON(jsonString: string): SafeParseResult<EventDataLoadingConfiguration, SDKValidationError>;
/** @internal */
export declare const EventDataUnion$inboundSchema: z.ZodType<EventDataUnion, unknown>;
export declare function eventDataUnionFromJSON(jsonString: string): SafeParseResult<EventDataUnion, SDKValidationError>;
/** @internal */
export declare const EventStateSuccess$inboundSchema: z.ZodEnum<typeof EventStateSuccess>;
/** @internal */
export declare const EventStateStarted$inboundSchema: z.ZodEnum<typeof EventStateStarted>;
/** @internal */
export declare const EventStateNone$inboundSchema: z.ZodEnum<typeof EventStateNone>;
/** @internal */
export declare const EventStateError$inboundSchema: z.ZodType<EventStateError, unknown>;
export declare function eventStateErrorFromJSON(jsonString: string): SafeParseResult<EventStateError, SDKValidationError>;
/** @internal */
export declare const EventStateErrorUnion$inboundSchema: z.ZodType<EventStateErrorUnion, unknown>;
export declare function eventStateErrorUnionFromJSON(jsonString: string): SafeParseResult<EventStateErrorUnion, SDKValidationError>;
/** @internal */
export declare const EventFailed$inboundSchema: z.ZodType<EventFailed, unknown>;
export declare function eventFailedFromJSON(jsonString: string): SafeParseResult<EventFailed, SDKValidationError>;
/** @internal */
export declare const EventState$inboundSchema: z.ZodType<EventState, unknown>;
export declare function eventStateFromJSON(jsonString: string): SafeParseResult<EventState, SDKValidationError>;
/** @internal */
export declare const EventStateUnion$inboundSchema: z.ZodType<EventStateUnion, unknown>;
export declare function eventStateUnionFromJSON(jsonString: string): SafeParseResult<EventStateUnion, SDKValidationError>;
/** @internal */
export declare const Event$inboundSchema: z.ZodType<Event, unknown>;
export declare function eventFromJSON(jsonString: string): SafeParseResult<Event, SDKValidationError>;
//# sourceMappingURL=event.d.ts.map