@alienplatform/platform-api 3.3.28 → 3.3.29

package/esm/models/targetreleasesupportedplatform.d.ts

@@ -0,0 +1,3814 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { DeploymentStateDeployerSecret, DeploymentStateDeployerSecret$Outbound, DeploymentStateInitialSetupAuthority } from "./deploymentstatependingpreparedstackoverrideazurestack.js";
+import { DeploymentStatePendingPreparedStackUnion, DeploymentStatePendingPreparedStackUnion$Outbound, DeploymentStatePreparedStackInput, DeploymentStatePreparedStackInput$Outbound, DeploymentStatePreparedStackManagementUnion, DeploymentStatePreparedStackManagementUnion$Outbound, DeploymentStatePreparedStackProfileAw, DeploymentStatePreparedStackProfileAw$Outbound, DeploymentStatePreparedStackProfileAzureResource, DeploymentStatePreparedStackProfileAzureResource$Outbound, DeploymentStatePreparedStackProfileAzureStack, DeploymentStatePreparedStackProfileAzureStack$Outbound } from "./deploymentstatepreparedstackprofileazurestack.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Generic binding configuration for permissions
+ */
+export type DeploymentStatePreparedStackProfileAzureBinding = {
+    /**
+     * Azure-specific binding specification
+     */
+    resource?: DeploymentStatePreparedStackProfileAzureResource | undefined;
+    /**
+     * Azure-specific binding specification
+     */
+    stack?: DeploymentStatePreparedStackProfileAzureStack | undefined;
+};
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type DeploymentStatePreparedStackProfileAzureGrant = {
+    /**
+     * AWS IAM actions (only for AWS)
+     */
+    actions?: Array<string> | null | undefined;
+    /**
+     * Azure actions (only for Azure)
+     */
+    dataActions?: Array<string> | null | undefined;
+    /**
+     * GCP permissions that require an exact residual custom role.
+     */
+    permissions?: Array<string> | null | undefined;
+    /**
+     * Provider predefined roles to bind directly.
+     */
+    predefinedRoles?: Array<string> | null | undefined;
+    /**
+     * GCP residual custom permissions to pair with predefined roles.
+     */
+    residualPermissions?: Array<string> | null | undefined;
+};
+/**
+ * Azure-specific platform permission configuration
+ */
+export type DeploymentStatePreparedStackProfileAzure = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: DeploymentStatePreparedStackProfileAzureBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: DeploymentStatePreparedStackProfileAzureGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * GCP IAM condition
+ */
+export type DeploymentStatePreparedStackProfileConditionResource = {
+    expression: string;
+    title: string;
+};
+export type DeploymentStatePreparedStackProfileResourceConditionUnion = DeploymentStatePreparedStackProfileConditionResource | string;
+/**
+ * GCP-specific binding specification
+ */
+export type DeploymentStatePreparedStackProfileGcpResource = {
+    condition?: DeploymentStatePreparedStackProfileConditionResource | string | null | undefined;
+    /**
+     * Scope (project/resource level)
+     */
+    scope: string;
+};
+/**
+ * GCP IAM condition
+ */
+export type DeploymentStatePreparedStackProfileConditionStack = {
+    expression: string;
+    title: string;
+};
+export type DeploymentStatePreparedStackProfileStackConditionUnion = DeploymentStatePreparedStackProfileConditionStack | string;
+/**
+ * GCP-specific binding specification
+ */
+export type DeploymentStatePreparedStackProfileGcpStack = {
+    condition?: DeploymentStatePreparedStackProfileConditionStack | string | null | undefined;
+    /**
+     * Scope (project/resource level)
+     */
+    scope: string;
+};
+/**
+ * Generic binding configuration for permissions
+ */
+export type DeploymentStatePreparedStackProfileGcpBinding = {
+    /**
+     * GCP-specific binding specification
+     */
+    resource?: DeploymentStatePreparedStackProfileGcpResource | undefined;
+    /**
+     * GCP-specific binding specification
+     */
+    stack?: DeploymentStatePreparedStackProfileGcpStack | undefined;
+};
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type DeploymentStatePreparedStackProfileGcpGrant = {
+    /**
+     * AWS IAM actions (only for AWS)
+     */
+    actions?: Array<string> | null | undefined;
+    /**
+     * Azure actions (only for Azure)
+     */
+    dataActions?: Array<string> | null | undefined;
+    /**
+     * GCP permissions that require an exact residual custom role.
+     */
+    permissions?: Array<string> | null | undefined;
+    /**
+     * Provider predefined roles to bind directly.
+     */
+    predefinedRoles?: Array<string> | null | undefined;
+    /**
+     * GCP residual custom permissions to pair with predefined roles.
+     */
+    residualPermissions?: Array<string> | null | undefined;
+};
+/**
+ * GCP-specific platform permission configuration
+ */
+export type DeploymentStatePreparedStackProfileGcp = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: DeploymentStatePreparedStackProfileGcpBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: DeploymentStatePreparedStackProfileGcpGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * Platform-specific permission configurations
+ */
+export type DeploymentStatePreparedStackProfilePlatforms = {
+    /**
+     * AWS permission configurations
+     */
+    aws?: Array<DeploymentStatePreparedStackProfileAw> | null | undefined;
+    /**
+     * Azure permission configurations
+     */
+    azure?: Array<DeploymentStatePreparedStackProfileAzure> | null | undefined;
+    /**
+     * GCP permission configurations
+     */
+    gcp?: Array<DeploymentStatePreparedStackProfileGcp> | null | undefined;
+};
+/**
+ * A permission set that can be applied across different cloud platforms
+ */
+export type DeploymentStatePreparedStackProfile = {
+    /**
+     * Human-readable description of what this permission set allows
+     */
+    description: string;
+    /**
+     * Unique identifier for the permission set (e.g., "storage/data-read")
+     */
+    id: string;
+    /**
+     * Platform-specific permission configurations
+     */
+    platforms: DeploymentStatePreparedStackProfilePlatforms;
+};
+/**
+ * Reference to a permission set - either by name or inline definition
+ */
+export type DeploymentStatePreparedStackProfileUnion = DeploymentStatePreparedStackProfile | string;
+/**
+ * Combined permissions configuration that contains both profiles and management
+ */
+export type DeploymentStatePreparedStackPermissions = {
+    /**
+     * Management permissions configuration for stack management access
+     */
+    management?: DeploymentStatePreparedStackManagementUnion | undefined;
+    /**
+     * Permission profiles that define access control for compute services
+     *
+     * @remarks
+     * Key is the profile name, value is the permission configuration
+     */
+    profiles: {
+        [k: string]: {
+            [k: string]: Array<DeploymentStatePreparedStackProfile | string>;
+        };
+    };
+};
+/**
+ * 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 DeploymentStatePreparedStackConfig = {
+    /**
+     * 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;
+};
+/**
+ * Reference to a resource by its stable id and resource type.
+ */
+export type DeploymentStatePreparedStackDependency = {
+    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;
+};
+/**
+ * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
+ */
+export declare const DeploymentStatePreparedStackLifecycle: {
+    readonly Frozen: "frozen";
+    readonly Live: "live";
+};
+/**
+ * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
+ */
+export type DeploymentStatePreparedStackLifecycle = ClosedEnum<typeof DeploymentStatePreparedStackLifecycle>;
+export type DeploymentStatePreparedStackResources = {
+    /**
+     * 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: DeploymentStatePreparedStackConfig;
+    /**
+     * Additional dependencies for this resource beyond those defined in the resource itself.
+     *
+     * @remarks
+     * The total dependencies are: resource.get_dependencies() + this list
+     */
+    dependencies: Array<DeploymentStatePreparedStackDependency>;
+    /**
+     * Id of the boolean stack input that decides whether this resource is
+     *
+     * @remarks
+     * created at all. `None` means always create it.
+     *
+     * Set by `.enabled(input)` in the SDK. Setup emitters render the resource
+     * conditionally on the matching template variable, so a deployer who says no
+     * never gets the resource, its outputs, or anything derived from it.
+     */
+    enabledWhen?: string | null | undefined;
+    /**
+     * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
+     */
+    lifecycle: DeploymentStatePreparedStackLifecycle;
+    /**
+     * Enable remote bindings for this resource (BYOB use case).
+     *
+     * @remarks
+     * When true, binding params are synced to StackState's `remote_binding_params`.
+     * Default: false (prevents sensitive data in synced state).
+     */
+    remoteAccess?: boolean | undefined;
+};
+/**
+ * Represents the target cloud platform.
+ */
+export declare const DeploymentStatePreparedStackSupportedPlatform: {
+    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 DeploymentStatePreparedStackSupportedPlatform = ClosedEnum<typeof DeploymentStatePreparedStackSupportedPlatform>;
+/**
+ * A bag of resources, unaware of any cloud.
+ */
+export type DeploymentStatePreparedStack = {
+    /**
+     * Released Container resources whose image repositories are approved for
+     *
+     * @remarks
+     * containers created after installation.
+     */
+    dynamicContainerImageResources?: Array<string> | undefined;
+    /**
+     * Exact image repositories approved for containers created after installation.
+     *
+     * @remarks
+     * The runtime API also requires an immutable SHA-256 digest.
+     */
+    dynamicContainerRepositories?: Array<string> | undefined;
+    /**
+     * Unique identifier for the stack
+     */
+    id: string;
+    /**
+     * Input definitions required before setup or deployment can proceed.
+     */
+    inputs?: Array<DeploymentStatePreparedStackInput> | undefined;
+    /**
+     * Combined permissions configuration that contains both profiles and management
+     */
+    permissions?: DeploymentStatePreparedStackPermissions | undefined;
+    /**
+     * Map of resource IDs to their configurations and lifecycle settings
+     */
+    resources: {
+        [k: string]: DeploymentStatePreparedStackResources;
+    };
+    /**
+     * Which platforms this stack supports. When None, all platforms are supported.
+     */
+    supportedPlatforms?: Array<DeploymentStatePreparedStackSupportedPlatform> | null | undefined;
+};
+export type DeploymentStatePreparedStackUnion = DeploymentStatePreparedStack | string;
+/**
+ * The cross-account read a manager opened on Alien's registry for one deployment.
+ */
+export type DeploymentStateRegistryAccess = {
+    /**
+     * Repository identifiers the grant names, sorted.
+     */
+    repositories?: Array<string> | undefined;
+    /**
+     * Compute services the grant admits, sorted. Each pulls as its own principal, so a service
+     *
+     * @remarks
+     * added later needs the policy rewritten.
+     */
+    serviceTypes?: Array<string> | undefined;
+};
+export type DeploymentStateRegistryAccessUnion = DeploymentStateRegistryAccess | string;
+/**
+ * The objects that keep an AWS deny sandbox's sessions inside the VPC. Each id is recorded as
+ *
+ * @remarks
+ * soon as the object exists and cleared once it is deleted.
+ */
+export type DeploymentStateEgress = {
+    /**
+     * `AWS::Lambda::NetworkConnector` the sessions start with.
+     */
+    connectorArn?: string | null | undefined;
+    /**
+     * Cloud Control request creating or deleting the connector that AWS has not finished. Kept
+     *
+     * @remarks
+     * so the request's outcome, and AWS's reason when it fails, is read on a later call.
+     */
+    connectorRequest?: string | null | undefined;
+    /**
+     * IAM role Lambda assumes to place the connector's network interfaces.
+     */
+    operatorRoleName: string;
+    /**
+     * Security group permitting egress to loopback only.
+     */
+    securityGroupId?: string | null | undefined;
+};
+export type DeploymentStateEgressUnion = DeploymentStateEgress | string;
+export declare const DeploymentStateTypeAwsSandbox: {
+    readonly AwsSandbox: "awsSandbox";
+};
+export type DeploymentStateTypeAwsSandbox = ClosedEnum<typeof DeploymentStateTypeAwsSandbox>;
+/**
+ * Cloud objects a direct setup created so a runtime-owned resource can run.
+ */
+export type DeploymentStateSetupScaffolding = {
+    /**
+     * IAM role the image build runs as.
+     */
+    buildRoleName: string;
+    egress?: DeploymentStateEgress | string | null | undefined;
+    /**
+     * A Frozen sandbox's MicroVM image, built during setup. A Live one's image belongs to its
+     *
+     * @remarks
+     * runtime controller.
+     */
+    imageArn?: string | null | undefined;
+    type: DeploymentStateTypeAwsSandbox;
+};
+/**
+ * One-shot authority for a setup re-import to replace setup-owned resources.
+ */
+export type DeploymentStateSetupUpdateAuthorization = {
+    /**
+     * Setup-owned digest (`Stack::setup_owned_digest`) of the last successful deployment.
+     */
+    baselineFrozenDigest: string;
+    /**
+     * Unique revision used by persistence layers for compare-and-swap updates.
+     */
+    nonce: string;
+    /**
+     * Release whose stack was prepared by setup.
+     */
+    releaseId: string;
+    /**
+     * Exact setup artifact revision that authored this authority.
+     */
+    setupFingerprint: string;
+    /**
+     * Setup fingerprint contract version.
+     */
+    setupFingerprintVersion: number;
+    /**
+     * Stable setup target recorded on the imported deployment.
+     */
+    setupTarget: string;
+    /**
+     * Setup-owned digest (`Stack::setup_owned_digest`) of the stack the setup re-import prepared.
+     */
+    targetFrozenDigest: string;
+};
+export type DeploymentStateSetupUpdateAuthorizationUnion = DeploymentStateSetupUpdateAuthorization | string;
+/**
+ * Runtime metadata for deployment
+ *
+ * @remarks
+ *
+ * Stores deployment state that needs to persist across step calls.
+ */
+export type DeploymentStateRuntimeMetadata = {
+    /**
+     * Whether each vault-native deployer secret is in the customer's secret
+     *
+     * @remarks
+     * store, with where it goes. Checked from metadata only; no value is ever
+     * read or recorded here.
+     */
+    deployerSecrets?: Array<DeploymentStateDeployerSecret> | undefined;
+    /**
+     * Last generated CLI package revision whose direct setup was applied.
+     *
+     * @remarks
+     * This lets a newer generated CLI refresh setup-owned infrastructure once
+     * before handing runtime changes back to the hosted manager.
+     */
+    directSetupRevision?: string | null | undefined;
+    /**
+     * Actor that owns structural work during the initial setup phase.
+     */
+    initialSetupAuthority?: DeploymentStateInitialSetupAuthority | undefined;
+    /**
+     * Hash of the environment variables snapshot that was last synced to the vault
+     *
+     * @remarks
+     * Used to avoid redundant sync operations during incremental deployment
+     */
+    lastSyncedEnvVarsHash?: string | null | undefined;
+    /**
+     * Exact vault keys owned by the deployment secret synchronizer. This
+     *
+     * @remarks
+     * inventory lets a later snapshot delete removed keys without listing or
+     * touching unrelated values in the same vault.
+     */
+    lastSyncedSecretNames?: Array<string> | undefined;
+    /**
+     * Release `pending_prepared_stack` was prepared from. The target can move
+     *
+     * @remarks
+     * to a newer release while that stack is still being applied; this tells
+     * the update which release actually converged.
+     */
+    pendingPreparedReleaseId?: string | null | undefined;
+    pendingPreparedStack?: DeploymentStatePendingPreparedStackUnion | null | undefined;
+    /**
+     * Canonical resolved answers for inputs that gate Frozen resources,
+     *
+     * @remarks
+     * keyed by input id, recorded when the deployment is created or its
+     * setup import registers.
+     *
+     * A frozen gate's answer is fixed for the deployment's lifetime: the
+     * update path refuses input values that conflict with these, and a Live
+     * resource sharing such an input resolves the persisted answer forever.
+     */
+    persistedGateAnswers?: {
+        [k: string]: boolean;
+    } | undefined;
+    preparedStack?: DeploymentStatePreparedStack | string | null | undefined;
+    registryAccess?: DeploymentStateRegistryAccess | string | null | undefined;
+    /**
+     * Whether cross-account registry access has been successfully granted.
+     *
+     * @remarks
+     * Set to true after the manager successfully sets the ECR/GAR repo policy
+     * for this deployment's target account. Prevents redundant API calls on
+     * every reconcile tick.
+     */
+    registryAccessGranted?: boolean | undefined;
+    /**
+     * What a direct setup created for resources it does not own, keyed by resource id. Setup
+     *
+     * @remarks
+     * teardown removes exactly what is recorded here.
+     */
+    setupScaffolding?: {
+        [k: string]: DeploymentStateSetupScaffolding;
+    } | undefined;
+    setupUpdateAuthorization?: DeploymentStateSetupUpdateAuthorization | string | null | undefined;
+};
+export type RuntimeMetadata = DeploymentStateRuntimeMetadata | string;
+/**
+ * Represents the target cloud platform.
+ */
+export declare const DeploymentStateStackStatePlatform: {
+    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 DeploymentStateStackStatePlatform = ClosedEnum<typeof DeploymentStateStackStatePlatform>;
+/**
+ * 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 DeploymentStateStackStateConfig = {
+    /**
+     * 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 DeploymentStateControllerPlatformEnum: {
+    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 DeploymentStateControllerPlatformEnum = ClosedEnum<typeof DeploymentStateControllerPlatformEnum>;
+export type DeploymentStateControllerPlatformUnion = DeploymentStateControllerPlatformEnum | string;
+/**
+ * Reference to a resource by its stable id and resource type.
+ */
+export type DeploymentStateStackStateDependency = {
+    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 DeploymentStateStackStateError = {
+    /**
+     * 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 | undefined;
+    /**
+     * 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 DeploymentStateStackStateErrorUnion = DeploymentStateStackStateError | string;
+/**
+ * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
+ */
+export declare const DeploymentStateStackStateLifecycleEnum: {
+    readonly Frozen: "frozen";
+    readonly Live: "live";
+};
+/**
+ * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
+ */
+export type DeploymentStateStackStateLifecycleEnum = ClosedEnum<typeof DeploymentStateStackStateLifecycleEnum>;
+export type DeploymentStateLifecycleUnion = DeploymentStateStackStateLifecycleEnum | string;
+/**
+ * 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 DeploymentStateOutputs = {
+    /**
+     * 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 DeploymentStateOutputsUnion = DeploymentStateOutputs | string;
+/**
+ * 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 DeploymentStatePreviousConfig = {
+    /**
+     * 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 DeploymentStatePreviousConfigUnion = DeploymentStatePreviousConfig | string;
+/**
+ * Represents the high-level status of a resource during its lifecycle.
+ */
+export declare const DeploymentStateStackStateStatus: {
+    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 DeploymentStateStackStateStatus = ClosedEnum<typeof DeploymentStateStackStateStatus>;
+/**
+ * Represents the state of a single resource within the stack for a specific platform.
+ */
+export type DeploymentStateStackStateResources = {
+    /**
+     * 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: DeploymentStateStackStateConfig;
+    controllerPlatform?: DeploymentStateControllerPlatformEnum | string | 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<DeploymentStateStackStateDependency> | undefined;
+    error?: DeploymentStateStackStateError | string | 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?: DeploymentStateStackStateLifecycleEnum | string | null | undefined;
+    outputs?: DeploymentStateOutputs | string | null | undefined;
+    previousConfig?: DeploymentStatePreviousConfig | string | 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: DeploymentStateStackStateStatus;
+    /**
+     * 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 DeploymentStateStackState = {
+    /**
+     * Represents the target cloud platform.
+     */
+    platform: DeploymentStateStackStatePlatform;
+    /**
+     * 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]: DeploymentStateStackStateResources;
+    };
+};
+export type StackState = DeploymentStateStackState | string;
+/**
+ * Deployment status in the deployment lifecycle.
+ *
+ * @remarks
+ *
+ * For observe-only deployments with no release or stack state, `Running`
+ * means the Operator is attached. Connectivity comes from `lastHeartbeatAt`;
+ * resource health comes from inventory and resource heartbeat data.
+ */
+export declare const DeploymentStateStatus: {
+    readonly Pending: "pending";
+    readonly PreflightsFailed: "preflights-failed";
+    readonly InitialSetup: "initial-setup";
+    readonly InitialSetupFailed: "initial-setup-failed";
+    readonly Provisioning: "provisioning";
+    readonly WaitingForMachines: "waiting-for-machines";
+    readonly WaitingForSecrets: "waiting-for-secrets";
+    readonly ProvisioningFailed: "provisioning-failed";
+    readonly Running: "running";
+    readonly RefreshFailed: "refresh-failed";
+    readonly UpdatePending: "update-pending";
+    readonly Updating: "updating";
+    readonly UpdateFailed: "update-failed";
+    readonly DeletePending: "delete-pending";
+    readonly Deleting: "deleting";
+    readonly DeleteFailed: "delete-failed";
+    readonly TeardownRequired: "teardown-required";
+    readonly TeardownFailed: "teardown-failed";
+    readonly Deleted: "deleted";
+    readonly Error: "error";
+};
+/**
+ * Deployment status in the deployment lifecycle.
+ *
+ * @remarks
+ *
+ * For observe-only deployments with no release or stack state, `Running`
+ * means the Operator is attached. Connectivity comes from `lastHeartbeatAt`;
+ * resource health comes from inventory and resource heartbeat data.
+ */
+export type DeploymentStateStatus = ClosedEnum<typeof DeploymentStateStatus>;
+export declare const TargetReleaseTypeStringList: {
+    readonly StringList: "stringList";
+};
+export type TargetReleaseTypeStringList = ClosedEnum<typeof TargetReleaseTypeStringList>;
+export type TargetReleaseDefaultStringList = {
+    type: TargetReleaseTypeStringList;
+    /**
+     * String list default.
+     */
+    value: Array<string>;
+};
+export declare const TargetReleaseTypeBoolean: {
+    readonly Boolean: "boolean";
+};
+export type TargetReleaseTypeBoolean = ClosedEnum<typeof TargetReleaseTypeBoolean>;
+export type TargetReleaseDefaultBoolean = {
+    type: TargetReleaseTypeBoolean;
+    /**
+     * Boolean default.
+     */
+    value: boolean;
+};
+export declare const TargetReleaseTypeNumber: {
+    readonly Number: "number";
+};
+export type TargetReleaseTypeNumber = ClosedEnum<typeof TargetReleaseTypeNumber>;
+export type TargetReleaseDefaultNumber = {
+    type: TargetReleaseTypeNumber;
+    /**
+     * Number default.
+     */
+    value: string;
+};
+export declare const TargetReleaseTypeString: {
+    readonly String: "string";
+};
+export type TargetReleaseTypeString = ClosedEnum<typeof TargetReleaseTypeString>;
+export type TargetReleaseDefaultString = {
+    type: TargetReleaseTypeString;
+    /**
+     * String default.
+     */
+    value: string;
+};
+export type TargetReleaseDefaultUnion = TargetReleaseDefaultString | TargetReleaseDefaultNumber | TargetReleaseDefaultBoolean | TargetReleaseDefaultStringList | string;
+/**
+ * Environment variable handling for a stack input mapping.
+ */
+export declare const TargetReleaseTypeEnvEnum: {
+    readonly Plain: "plain";
+    readonly Secret: "secret";
+};
+/**
+ * Environment variable handling for a stack input mapping.
+ */
+export type TargetReleaseTypeEnvEnum = ClosedEnum<typeof TargetReleaseTypeEnvEnum>;
+export type TargetReleaseTypeUnion = TargetReleaseTypeEnvEnum | string;
+/**
+ * How a resolved stack input is injected into runtime environment variables.
+ */
+export type TargetReleaseEnv = {
+    /**
+     * Environment variable name.
+     */
+    name: string;
+    /**
+     * Target resource IDs or patterns. None means every env-capable resource.
+     */
+    targetResources?: Array<string> | null | undefined;
+    type?: TargetReleaseTypeEnvEnum | string | null | undefined;
+};
+/**
+ * Asks Alien to generate a secret input's value.
+ *
+ * @remarks
+ *
+ * The value is an alphanumeric string (`A-Z`, `a-z`, `0-9`), so it is safe in
+ * connection strings, command lines and environment variables. It is generated
+ * once, when the deployment's input values are first resolved, and then kept
+ * with the deployment's other input values.
+ */
+export type TargetReleaseGenerate = {
+    /**
+     * Number of characters to generate.
+     */
+    length: number;
+};
+export type TargetReleaseGenerateUnion = TargetReleaseGenerate | string;
+/**
+ * Primitive stack input kind.
+ */
+export declare const TargetReleaseKind: {
+    readonly String: "string";
+    readonly Secret: "secret";
+    readonly Number: "number";
+    readonly Integer: "integer";
+    readonly Boolean: "boolean";
+    readonly Enum: "enum";
+    readonly StringList: "stringList";
+};
+/**
+ * Primitive stack input kind.
+ */
+export type TargetReleaseKind = ClosedEnum<typeof TargetReleaseKind>;
+/**
+ * Represents the target cloud platform.
+ */
+export declare const TargetReleasePlatform: {
+    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 TargetReleasePlatform = ClosedEnum<typeof TargetReleasePlatform>;
+/**
+ * Who can provide a stack input value.
+ */
+export declare const TargetReleaseProvidedBy: {
+    readonly Developer: "developer";
+    readonly Deployer: "deployer";
+};
+/**
+ * Who can provide a stack input value.
+ */
+export type TargetReleaseProvidedBy = ClosedEnum<typeof TargetReleaseProvidedBy>;
+/**
+ * Portable stack input validation constraints.
+ */
+export type TargetReleaseValidation = {
+    /**
+     * Semantic format hint such as url.
+     */
+    format?: string | null | undefined;
+    /**
+     * Maximum number.
+     */
+    max?: string | null | undefined;
+    /**
+     * Maximum string-list items.
+     */
+    maxItems?: number | null | undefined;
+    /**
+     * Maximum string length.
+     */
+    maxLength?: number | null | undefined;
+    /**
+     * Minimum number.
+     */
+    min?: string | null | undefined;
+    /**
+     * Minimum string-list items.
+     */
+    minItems?: number | null | undefined;
+    /**
+     * Minimum string length.
+     */
+    minLength?: number | null | undefined;
+    /**
+     * Portable whole-value regex pattern.
+     */
+    pattern?: string | null | undefined;
+    /**
+     * Allowed string enum values.
+     */
+    values?: Array<string> | null | undefined;
+};
+export type TargetReleaseValidationUnion = TargetReleaseValidation | string;
+/**
+ * Stack input definition serialized into a release stack.
+ */
+export type TargetReleaseInput = {
+    default?: TargetReleaseDefaultString | TargetReleaseDefaultNumber | TargetReleaseDefaultBoolean | TargetReleaseDefaultStringList | string | null | undefined;
+    /**
+     * Human-facing helper text.
+     */
+    description: string;
+    /**
+     * Runtime env-var mappings for v1 input resolution.
+     */
+    env?: Array<TargetReleaseEnv> | undefined;
+    generate?: TargetReleaseGenerate | string | null | undefined;
+    /**
+     * Stable input ID used by CLI/API calls.
+     */
+    id: string;
+    /**
+     * Primitive stack input kind.
+     */
+    kind: TargetReleaseKind;
+    /**
+     * Human-facing field label.
+     */
+    label: string;
+    /**
+     * Example placeholder shown in UI.
+     */
+    placeholder?: string | null | undefined;
+    /**
+     * Platforms where this input applies.
+     */
+    platforms?: Array<TargetReleasePlatform> | null | undefined;
+    /**
+     * Who can provide this value.
+     */
+    providedBy: Array<TargetReleaseProvidedBy>;
+    /**
+     * Whether a resolved value is required before deployment can proceed.
+     */
+    required: boolean;
+    validation?: TargetReleaseValidation | string | null | undefined;
+};
+export declare const TargetReleaseManagementEnum: {
+    readonly Auto: "auto";
+};
+export type TargetReleaseManagementEnum = ClosedEnum<typeof TargetReleaseManagementEnum>;
+/**
+ * AWS-specific binding specification
+ */
+export type TargetReleaseOverrideAwResource = {
+    /**
+     * Optional condition for additional filtering (rare)
+     */
+    condition?: {
+        [k: string]: {
+            [k: string]: string;
+        };
+    } | null | undefined;
+    /**
+     * ARN patterns rendered as IAM `NotResource`, in place of `resources`. Its one use is a
+     *
+     * @remarks
+     * tag-on-create grant whose implied check AWS authorizes against no resource; the build
+     * refuses it anywhere else.
+     */
+    notResources?: Array<string> | undefined;
+    /**
+     * Resource ARNs to bind to
+     */
+    resources: Array<string>;
+};
+/**
+ * AWS-specific binding specification
+ */
+export type TargetReleaseOverrideAwStack = {
+    /**
+     * Optional condition for additional filtering (rare)
+     */
+    condition?: {
+        [k: string]: {
+            [k: string]: string;
+        };
+    } | null | undefined;
+    /**
+     * ARN patterns rendered as IAM `NotResource`, in place of `resources`. Its one use is a
+     *
+     * @remarks
+     * tag-on-create grant whose implied check AWS authorizes against no resource; the build
+     * refuses it anywhere else.
+     */
+    notResources?: Array<string> | undefined;
+    /**
+     * Resource ARNs to bind to
+     */
+    resources: Array<string>;
+};
+/**
+ * Generic binding configuration for permissions
+ */
+export type TargetReleaseOverrideAwBinding = {
+    /**
+     * AWS-specific binding specification
+     */
+    resource?: TargetReleaseOverrideAwResource | undefined;
+    /**
+     * AWS-specific binding specification
+     */
+    stack?: TargetReleaseOverrideAwStack | undefined;
+};
+/**
+ * IAM effect. Defaults to Allow.
+ */
+export declare const TargetReleaseOverrideEffect: {
+    readonly Allow: "Allow";
+    readonly Deny: "Deny";
+};
+/**
+ * IAM effect. Defaults to Allow.
+ */
+export type TargetReleaseOverrideEffect = ClosedEnum<typeof TargetReleaseOverrideEffect>;
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type TargetReleaseOverrideAwGrant = {
+    /**
+     * AWS IAM actions (only for AWS)
+     */
+    actions?: Array<string> | null | undefined;
+    /**
+     * Azure actions (only for Azure)
+     */
+    dataActions?: Array<string> | null | undefined;
+    /**
+     * GCP permissions that require an exact residual custom role.
+     */
+    permissions?: Array<string> | null | undefined;
+    /**
+     * Provider predefined roles to bind directly.
+     */
+    predefinedRoles?: Array<string> | null | undefined;
+    /**
+     * GCP residual custom permissions to pair with predefined roles.
+     */
+    residualPermissions?: Array<string> | null | undefined;
+};
+/**
+ * AWS-specific platform permission configuration
+ */
+export type TargetReleaseOverrideAw = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: TargetReleaseOverrideAwBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * IAM effect. Defaults to Allow.
+     */
+    effect?: TargetReleaseOverrideEffect | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: TargetReleaseOverrideAwGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * Azure-specific binding specification
+ */
+export type TargetReleaseOverrideAzureResource = {
+    /**
+     * Scope (subscription/resource group/resource level)
+     */
+    scope: string;
+};
+/**
+ * Azure-specific binding specification
+ */
+export type TargetReleaseOverrideAzureStack = {
+    /**
+     * Scope (subscription/resource group/resource level)
+     */
+    scope: string;
+};
+/**
+ * Generic binding configuration for permissions
+ */
+export type TargetReleaseOverrideAzureBinding = {
+    /**
+     * Azure-specific binding specification
+     */
+    resource?: TargetReleaseOverrideAzureResource | undefined;
+    /**
+     * Azure-specific binding specification
+     */
+    stack?: TargetReleaseOverrideAzureStack | undefined;
+};
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type TargetReleaseOverrideAzureGrant = {
+    /**
+     * AWS IAM actions (only for AWS)
+     */
+    actions?: Array<string> | null | undefined;
+    /**
+     * Azure actions (only for Azure)
+     */
+    dataActions?: Array<string> | null | undefined;
+    /**
+     * GCP permissions that require an exact residual custom role.
+     */
+    permissions?: Array<string> | null | undefined;
+    /**
+     * Provider predefined roles to bind directly.
+     */
+    predefinedRoles?: Array<string> | null | undefined;
+    /**
+     * GCP residual custom permissions to pair with predefined roles.
+     */
+    residualPermissions?: Array<string> | null | undefined;
+};
+/**
+ * Azure-specific platform permission configuration
+ */
+export type TargetReleaseOverrideAzure = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: TargetReleaseOverrideAzureBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: TargetReleaseOverrideAzureGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * GCP IAM condition
+ */
+export type TargetReleaseOverrideConditionResource = {
+    expression: string;
+    title: string;
+};
+export type TargetReleaseOverrideResourceConditionUnion = TargetReleaseOverrideConditionResource | string;
+/**
+ * GCP-specific binding specification
+ */
+export type TargetReleaseOverrideGcpResource = {
+    condition?: TargetReleaseOverrideConditionResource | string | null | undefined;
+    /**
+     * Scope (project/resource level)
+     */
+    scope: string;
+};
+/**
+ * GCP IAM condition
+ */
+export type TargetReleaseOverrideCondition = {
+    expression: string;
+    title: string;
+};
+export type TargetReleaseOverrideConditionUnion = TargetReleaseOverrideCondition | string;
+/**
+ * GCP-specific binding specification
+ */
+export type TargetReleaseOverrideGcpStack = {
+    condition?: TargetReleaseOverrideCondition | string | null | undefined;
+    /**
+     * Scope (project/resource level)
+     */
+    scope: string;
+};
+/**
+ * Generic binding configuration for permissions
+ */
+export type TargetReleaseOverrideGcpBinding = {
+    /**
+     * GCP-specific binding specification
+     */
+    resource?: TargetReleaseOverrideGcpResource | undefined;
+    /**
+     * GCP-specific binding specification
+     */
+    stack?: TargetReleaseOverrideGcpStack | undefined;
+};
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type TargetReleaseOverrideGcpGrant = {
+    /**
+     * AWS IAM actions (only for AWS)
+     */
+    actions?: Array<string> | null | undefined;
+    /**
+     * Azure actions (only for Azure)
+     */
+    dataActions?: Array<string> | null | undefined;
+    /**
+     * GCP permissions that require an exact residual custom role.
+     */
+    permissions?: Array<string> | null | undefined;
+    /**
+     * Provider predefined roles to bind directly.
+     */
+    predefinedRoles?: Array<string> | null | undefined;
+    /**
+     * GCP residual custom permissions to pair with predefined roles.
+     */
+    residualPermissions?: Array<string> | null | undefined;
+};
+/**
+ * GCP-specific platform permission configuration
+ */
+export type TargetReleaseOverrideGcp = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: TargetReleaseOverrideGcpBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: TargetReleaseOverrideGcpGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * Platform-specific permission configurations
+ */
+export type TargetReleaseOverridePlatforms = {
+    /**
+     * AWS permission configurations
+     */
+    aws?: Array<TargetReleaseOverrideAw> | null | undefined;
+    /**
+     * Azure permission configurations
+     */
+    azure?: Array<TargetReleaseOverrideAzure> | null | undefined;
+    /**
+     * GCP permission configurations
+     */
+    gcp?: Array<TargetReleaseOverrideGcp> | null | undefined;
+};
+/**
+ * A permission set that can be applied across different cloud platforms
+ */
+export type TargetReleaseOverride = {
+    /**
+     * Human-readable description of what this permission set allows
+     */
+    description: string;
+    /**
+     * Unique identifier for the permission set (e.g., "storage/data-read")
+     */
+    id: string;
+    /**
+     * Platform-specific permission configurations
+     */
+    platforms: TargetReleaseOverridePlatforms;
+};
+/**
+ * Reference to a permission set - either by name or inline definition
+ */
+export type TargetReleaseOverrideUnion = TargetReleaseOverride | string;
+export type TargetReleaseManagement2 = {
+    /**
+     * Permission profile that maps resources to permission sets
+     *
+     * @remarks
+     * Key can be "*" for all resources or resource name for specific resource
+     */
+    override: {
+        [k: string]: Array<TargetReleaseOverride | string>;
+    };
+};
+/**
+ * AWS-specific binding specification
+ */
+export type TargetReleaseExtendAwResource = {
+    /**
+     * Optional condition for additional filtering (rare)
+     */
+    condition?: {
+        [k: string]: {
+            [k: string]: string;
+        };
+    } | null | undefined;
+    /**
+     * ARN patterns rendered as IAM `NotResource`, in place of `resources`. Its one use is a
+     *
+     * @remarks
+     * tag-on-create grant whose implied check AWS authorizes against no resource; the build
+     * refuses it anywhere else.
+     */
+    notResources?: Array<string> | undefined;
+    /**
+     * Resource ARNs to bind to
+     */
+    resources: Array<string>;
+};
+/**
+ * AWS-specific binding specification
+ */
+export type TargetReleaseExtendAwStack = {
+    /**
+     * Optional condition for additional filtering (rare)
+     */
+    condition?: {
+        [k: string]: {
+            [k: string]: string;
+        };
+    } | null | undefined;
+    /**
+     * ARN patterns rendered as IAM `NotResource`, in place of `resources`. Its one use is a
+     *
+     * @remarks
+     * tag-on-create grant whose implied check AWS authorizes against no resource; the build
+     * refuses it anywhere else.
+     */
+    notResources?: Array<string> | undefined;
+    /**
+     * Resource ARNs to bind to
+     */
+    resources: Array<string>;
+};
+/**
+ * Generic binding configuration for permissions
+ */
+export type TargetReleaseExtendAwBinding = {
+    /**
+     * AWS-specific binding specification
+     */
+    resource?: TargetReleaseExtendAwResource | undefined;
+    /**
+     * AWS-specific binding specification
+     */
+    stack?: TargetReleaseExtendAwStack | undefined;
+};
+/**
+ * IAM effect. Defaults to Allow.
+ */
+export declare const TargetReleaseExtendEffect: {
+    readonly Allow: "Allow";
+    readonly Deny: "Deny";
+};
+/**
+ * IAM effect. Defaults to Allow.
+ */
+export type TargetReleaseExtendEffect = ClosedEnum<typeof TargetReleaseExtendEffect>;
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type TargetReleaseExtendAwGrant = {
+    /**
+     * AWS IAM actions (only for AWS)
+     */
+    actions?: Array<string> | null | undefined;
+    /**
+     * Azure actions (only for Azure)
+     */
+    dataActions?: Array<string> | null | undefined;
+    /**
+     * GCP permissions that require an exact residual custom role.
+     */
+    permissions?: Array<string> | null | undefined;
+    /**
+     * Provider predefined roles to bind directly.
+     */
+    predefinedRoles?: Array<string> | null | undefined;
+    /**
+     * GCP residual custom permissions to pair with predefined roles.
+     */
+    residualPermissions?: Array<string> | null | undefined;
+};
+/**
+ * AWS-specific platform permission configuration
+ */
+export type TargetReleaseExtendAw = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: TargetReleaseExtendAwBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * IAM effect. Defaults to Allow.
+     */
+    effect?: TargetReleaseExtendEffect | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: TargetReleaseExtendAwGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * Azure-specific binding specification
+ */
+export type TargetReleaseExtendAzureResource = {
+    /**
+     * Scope (subscription/resource group/resource level)
+     */
+    scope: string;
+};
+/**
+ * Azure-specific binding specification
+ */
+export type TargetReleaseExtendAzureStack = {
+    /**
+     * Scope (subscription/resource group/resource level)
+     */
+    scope: string;
+};
+/**
+ * Generic binding configuration for permissions
+ */
+export type TargetReleaseExtendAzureBinding = {
+    /**
+     * Azure-specific binding specification
+     */
+    resource?: TargetReleaseExtendAzureResource | undefined;
+    /**
+     * Azure-specific binding specification
+     */
+    stack?: TargetReleaseExtendAzureStack | undefined;
+};
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type TargetReleaseExtendAzureGrant = {
+    /**
+     * AWS IAM actions (only for AWS)
+     */
+    actions?: Array<string> | null | undefined;
+    /**
+     * Azure actions (only for Azure)
+     */
+    dataActions?: Array<string> | null | undefined;
+    /**
+     * GCP permissions that require an exact residual custom role.
+     */
+    permissions?: Array<string> | null | undefined;
+    /**
+     * Provider predefined roles to bind directly.
+     */
+    predefinedRoles?: Array<string> | null | undefined;
+    /**
+     * GCP residual custom permissions to pair with predefined roles.
+     */
+    residualPermissions?: Array<string> | null | undefined;
+};
+/**
+ * Azure-specific platform permission configuration
+ */
+export type TargetReleaseExtendAzure = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: TargetReleaseExtendAzureBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: TargetReleaseExtendAzureGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * GCP IAM condition
+ */
+export type TargetReleaseExtendConditionResource = {
+    expression: string;
+    title: string;
+};
+export type TargetReleaseExtendResourceConditionUnion = TargetReleaseExtendConditionResource | string;
+/**
+ * GCP-specific binding specification
+ */
+export type TargetReleaseExtendGcpResource = {
+    condition?: TargetReleaseExtendConditionResource | string | null | undefined;
+    /**
+     * Scope (project/resource level)
+     */
+    scope: string;
+};
+/**
+ * GCP IAM condition
+ */
+export type TargetReleaseExtendCondition = {
+    expression: string;
+    title: string;
+};
+export type TargetReleaseExtendConditionUnion = TargetReleaseExtendCondition | string;
+/**
+ * GCP-specific binding specification
+ */
+export type TargetReleaseExtendGcpStack = {
+    condition?: TargetReleaseExtendCondition | string | null | undefined;
+    /**
+     * Scope (project/resource level)
+     */
+    scope: string;
+};
+/**
+ * Generic binding configuration for permissions
+ */
+export type TargetReleaseExtendGcpBinding = {
+    /**
+     * GCP-specific binding specification
+     */
+    resource?: TargetReleaseExtendGcpResource | undefined;
+    /**
+     * GCP-specific binding specification
+     */
+    stack?: TargetReleaseExtendGcpStack | undefined;
+};
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type TargetReleaseExtendGcpGrant = {
+    /**
+     * AWS IAM actions (only for AWS)
+     */
+    actions?: Array<string> | null | undefined;
+    /**
+     * Azure actions (only for Azure)
+     */
+    dataActions?: Array<string> | null | undefined;
+    /**
+     * GCP permissions that require an exact residual custom role.
+     */
+    permissions?: Array<string> | null | undefined;
+    /**
+     * Provider predefined roles to bind directly.
+     */
+    predefinedRoles?: Array<string> | null | undefined;
+    /**
+     * GCP residual custom permissions to pair with predefined roles.
+     */
+    residualPermissions?: Array<string> | null | undefined;
+};
+/**
+ * GCP-specific platform permission configuration
+ */
+export type TargetReleaseExtendGcp = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: TargetReleaseExtendGcpBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: TargetReleaseExtendGcpGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * Platform-specific permission configurations
+ */
+export type TargetReleaseExtendPlatforms = {
+    /**
+     * AWS permission configurations
+     */
+    aws?: Array<TargetReleaseExtendAw> | null | undefined;
+    /**
+     * Azure permission configurations
+     */
+    azure?: Array<TargetReleaseExtendAzure> | null | undefined;
+    /**
+     * GCP permission configurations
+     */
+    gcp?: Array<TargetReleaseExtendGcp> | null | undefined;
+};
+/**
+ * A permission set that can be applied across different cloud platforms
+ */
+export type TargetReleaseExtend = {
+    /**
+     * Human-readable description of what this permission set allows
+     */
+    description: string;
+    /**
+     * Unique identifier for the permission set (e.g., "storage/data-read")
+     */
+    id: string;
+    /**
+     * Platform-specific permission configurations
+     */
+    platforms: TargetReleaseExtendPlatforms;
+};
+/**
+ * Reference to a permission set - either by name or inline definition
+ */
+export type TargetReleaseExtendUnion = TargetReleaseExtend | string;
+export type TargetReleaseManagement1 = {
+    /**
+     * Permission profile that maps resources to permission sets
+     *
+     * @remarks
+     * Key can be "*" for all resources or resource name for specific resource
+     */
+    extend: {
+        [k: string]: Array<TargetReleaseExtend | string>;
+    };
+};
+/**
+ * Management permissions configuration for stack management access
+ */
+export type TargetReleaseManagementUnion = TargetReleaseManagement1 | TargetReleaseManagement2 | TargetReleaseManagementEnum;
+/**
+ * AWS-specific binding specification
+ */
+export type TargetReleaseProfileAwResource = {
+    /**
+     * Optional condition for additional filtering (rare)
+     */
+    condition?: {
+        [k: string]: {
+            [k: string]: string;
+        };
+    } | null | undefined;
+    /**
+     * ARN patterns rendered as IAM `NotResource`, in place of `resources`. Its one use is a
+     *
+     * @remarks
+     * tag-on-create grant whose implied check AWS authorizes against no resource; the build
+     * refuses it anywhere else.
+     */
+    notResources?: Array<string> | undefined;
+    /**
+     * Resource ARNs to bind to
+     */
+    resources: Array<string>;
+};
+/**
+ * AWS-specific binding specification
+ */
+export type TargetReleaseProfileAwStack = {
+    /**
+     * Optional condition for additional filtering (rare)
+     */
+    condition?: {
+        [k: string]: {
+            [k: string]: string;
+        };
+    } | null | undefined;
+    /**
+     * ARN patterns rendered as IAM `NotResource`, in place of `resources`. Its one use is a
+     *
+     * @remarks
+     * tag-on-create grant whose implied check AWS authorizes against no resource; the build
+     * refuses it anywhere else.
+     */
+    notResources?: Array<string> | undefined;
+    /**
+     * Resource ARNs to bind to
+     */
+    resources: Array<string>;
+};
+/**
+ * Generic binding configuration for permissions
+ */
+export type TargetReleaseProfileAwBinding = {
+    /**
+     * AWS-specific binding specification
+     */
+    resource?: TargetReleaseProfileAwResource | undefined;
+    /**
+     * AWS-specific binding specification
+     */
+    stack?: TargetReleaseProfileAwStack | undefined;
+};
+/**
+ * IAM effect. Defaults to Allow.
+ */
+export declare const TargetReleaseProfileEffect: {
+    readonly Allow: "Allow";
+    readonly Deny: "Deny";
+};
+/**
+ * IAM effect. Defaults to Allow.
+ */
+export type TargetReleaseProfileEffect = ClosedEnum<typeof TargetReleaseProfileEffect>;
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type TargetReleaseProfileAwGrant = {
+    /**
+     * AWS IAM actions (only for AWS)
+     */
+    actions?: Array<string> | null | undefined;
+    /**
+     * Azure actions (only for Azure)
+     */
+    dataActions?: Array<string> | null | undefined;
+    /**
+     * GCP permissions that require an exact residual custom role.
+     */
+    permissions?: Array<string> | null | undefined;
+    /**
+     * Provider predefined roles to bind directly.
+     */
+    predefinedRoles?: Array<string> | null | undefined;
+    /**
+     * GCP residual custom permissions to pair with predefined roles.
+     */
+    residualPermissions?: Array<string> | null | undefined;
+};
+/**
+ * AWS-specific platform permission configuration
+ */
+export type TargetReleaseProfileAw = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: TargetReleaseProfileAwBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * IAM effect. Defaults to Allow.
+     */
+    effect?: TargetReleaseProfileEffect | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: TargetReleaseProfileAwGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * Azure-specific binding specification
+ */
+export type TargetReleaseProfileAzureResource = {
+    /**
+     * Scope (subscription/resource group/resource level)
+     */
+    scope: string;
+};
+/**
+ * Azure-specific binding specification
+ */
+export type TargetReleaseProfileAzureStack = {
+    /**
+     * Scope (subscription/resource group/resource level)
+     */
+    scope: string;
+};
+/**
+ * Generic binding configuration for permissions
+ */
+export type TargetReleaseProfileAzureBinding = {
+    /**
+     * Azure-specific binding specification
+     */
+    resource?: TargetReleaseProfileAzureResource | undefined;
+    /**
+     * Azure-specific binding specification
+     */
+    stack?: TargetReleaseProfileAzureStack | undefined;
+};
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type TargetReleaseProfileAzureGrant = {
+    /**
+     * AWS IAM actions (only for AWS)
+     */
+    actions?: Array<string> | null | undefined;
+    /**
+     * Azure actions (only for Azure)
+     */
+    dataActions?: Array<string> | null | undefined;
+    /**
+     * GCP permissions that require an exact residual custom role.
+     */
+    permissions?: Array<string> | null | undefined;
+    /**
+     * Provider predefined roles to bind directly.
+     */
+    predefinedRoles?: Array<string> | null | undefined;
+    /**
+     * GCP residual custom permissions to pair with predefined roles.
+     */
+    residualPermissions?: Array<string> | null | undefined;
+};
+/**
+ * Azure-specific platform permission configuration
+ */
+export type TargetReleaseProfileAzure = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: TargetReleaseProfileAzureBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: TargetReleaseProfileAzureGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * GCP IAM condition
+ */
+export type TargetReleaseProfileConditionResource = {
+    expression: string;
+    title: string;
+};
+export type TargetReleaseProfileResourceConditionUnion = TargetReleaseProfileConditionResource | string;
+/**
+ * GCP-specific binding specification
+ */
+export type TargetReleaseProfileGcpResource = {
+    condition?: TargetReleaseProfileConditionResource | string | null | undefined;
+    /**
+     * Scope (project/resource level)
+     */
+    scope: string;
+};
+/**
+ * GCP IAM condition
+ */
+export type TargetReleaseProfileCondition = {
+    expression: string;
+    title: string;
+};
+export type TargetReleaseProfileConditionUnion = TargetReleaseProfileCondition | string;
+/**
+ * GCP-specific binding specification
+ */
+export type TargetReleaseProfileGcpStack = {
+    condition?: TargetReleaseProfileCondition | string | null | undefined;
+    /**
+     * Scope (project/resource level)
+     */
+    scope: string;
+};
+/**
+ * Generic binding configuration for permissions
+ */
+export type TargetReleaseProfileGcpBinding = {
+    /**
+     * GCP-specific binding specification
+     */
+    resource?: TargetReleaseProfileGcpResource | undefined;
+    /**
+     * GCP-specific binding specification
+     */
+    stack?: TargetReleaseProfileGcpStack | undefined;
+};
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type TargetReleaseProfileGcpGrant = {
+    /**
+     * AWS IAM actions (only for AWS)
+     */
+    actions?: Array<string> | null | undefined;
+    /**
+     * Azure actions (only for Azure)
+     */
+    dataActions?: Array<string> | null | undefined;
+    /**
+     * GCP permissions that require an exact residual custom role.
+     */
+    permissions?: Array<string> | null | undefined;
+    /**
+     * Provider predefined roles to bind directly.
+     */
+    predefinedRoles?: Array<string> | null | undefined;
+    /**
+     * GCP residual custom permissions to pair with predefined roles.
+     */
+    residualPermissions?: Array<string> | null | undefined;
+};
+/**
+ * GCP-specific platform permission configuration
+ */
+export type TargetReleaseProfileGcp = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: TargetReleaseProfileGcpBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: TargetReleaseProfileGcpGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * Platform-specific permission configurations
+ */
+export type TargetReleaseProfilePlatforms = {
+    /**
+     * AWS permission configurations
+     */
+    aws?: Array<TargetReleaseProfileAw> | null | undefined;
+    /**
+     * Azure permission configurations
+     */
+    azure?: Array<TargetReleaseProfileAzure> | null | undefined;
+    /**
+     * GCP permission configurations
+     */
+    gcp?: Array<TargetReleaseProfileGcp> | null | undefined;
+};
+/**
+ * A permission set that can be applied across different cloud platforms
+ */
+export type TargetReleaseProfile = {
+    /**
+     * Human-readable description of what this permission set allows
+     */
+    description: string;
+    /**
+     * Unique identifier for the permission set (e.g., "storage/data-read")
+     */
+    id: string;
+    /**
+     * Platform-specific permission configurations
+     */
+    platforms: TargetReleaseProfilePlatforms;
+};
+/**
+ * Reference to a permission set - either by name or inline definition
+ */
+export type TargetReleaseProfileUnion = TargetReleaseProfile | string;
+/**
+ * Combined permissions configuration that contains both profiles and management
+ */
+export type TargetReleasePermissions = {
+    /**
+     * Management permissions configuration for stack management access
+     */
+    management?: TargetReleaseManagement1 | TargetReleaseManagement2 | TargetReleaseManagementEnum | undefined;
+    /**
+     * Permission profiles that define access control for compute services
+     *
+     * @remarks
+     * Key is the profile name, value is the permission configuration
+     */
+    profiles: {
+        [k: string]: {
+            [k: string]: Array<TargetReleaseProfile | string>;
+        };
+    };
+};
+/**
+ * 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 TargetReleaseConfig = {
+    /**
+     * 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;
+};
+/**
+ * Reference to a resource by its stable id and resource type.
+ */
+export type TargetReleaseDependency = {
+    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;
+};
+/**
+ * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
+ */
+export declare const TargetReleaseLifecycle: {
+    readonly Frozen: "frozen";
+    readonly Live: "live";
+};
+/**
+ * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
+ */
+export type TargetReleaseLifecycle = ClosedEnum<typeof TargetReleaseLifecycle>;
+export type TargetReleaseResources = {
+    /**
+     * 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: TargetReleaseConfig;
+    /**
+     * Additional dependencies for this resource beyond those defined in the resource itself.
+     *
+     * @remarks
+     * The total dependencies are: resource.get_dependencies() + this list
+     */
+    dependencies: Array<TargetReleaseDependency>;
+    /**
+     * Id of the boolean stack input that decides whether this resource is
+     *
+     * @remarks
+     * created at all. `None` means always create it.
+     *
+     * Set by `.enabled(input)` in the SDK. Setup emitters render the resource
+     * conditionally on the matching template variable, so a deployer who says no
+     * never gets the resource, its outputs, or anything derived from it.
+     */
+    enabledWhen?: string | null | undefined;
+    /**
+     * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
+     */
+    lifecycle: TargetReleaseLifecycle;
+    /**
+     * Enable remote bindings for this resource (BYOB use case).
+     *
+     * @remarks
+     * When true, binding params are synced to StackState's `remote_binding_params`.
+     * Default: false (prevents sensitive data in synced state).
+     */
+    remoteAccess?: boolean | undefined;
+};
+/**
+ * Represents the target cloud platform.
+ */
+export declare const TargetReleaseSupportedPlatform: {
+    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 TargetReleaseSupportedPlatform = ClosedEnum<typeof TargetReleaseSupportedPlatform>;
+/** @internal */
+export declare const DeploymentStatePreparedStackProfileAzureBinding$inboundSchema: z.ZodType<DeploymentStatePreparedStackProfileAzureBinding, unknown>;
+/** @internal */
+export type DeploymentStatePreparedStackProfileAzureBinding$Outbound = {
+    resource?: DeploymentStatePreparedStackProfileAzureResource$Outbound | undefined;
+    stack?: DeploymentStatePreparedStackProfileAzureStack$Outbound | undefined;
+};
+/** @internal */
+export declare const DeploymentStatePreparedStackProfileAzureBinding$outboundSchema: z.ZodType<DeploymentStatePreparedStackProfileAzureBinding$Outbound, DeploymentStatePreparedStackProfileAzureBinding>;
+export declare function deploymentStatePreparedStackProfileAzureBindingToJSON(deploymentStatePreparedStackProfileAzureBinding: DeploymentStatePreparedStackProfileAzureBinding): string;
+export declare function deploymentStatePreparedStackProfileAzureBindingFromJSON(jsonString: string): SafeParseResult<DeploymentStatePreparedStackProfileAzureBinding, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePreparedStackProfileAzureGrant$inboundSchema: z.ZodType<DeploymentStatePreparedStackProfileAzureGrant, unknown>;
+/** @internal */
+export type DeploymentStatePreparedStackProfileAzureGrant$Outbound = {
+    actions?: Array<string> | null | undefined;
+    dataActions?: Array<string> | null | undefined;
+    permissions?: Array<string> | null | undefined;
+    predefinedRoles?: Array<string> | null | undefined;
+    residualPermissions?: Array<string> | null | undefined;
+};
+/** @internal */
+export declare const DeploymentStatePreparedStackProfileAzureGrant$outboundSchema: z.ZodType<DeploymentStatePreparedStackProfileAzureGrant$Outbound, DeploymentStatePreparedStackProfileAzureGrant>;
+export declare function deploymentStatePreparedStackProfileAzureGrantToJSON(deploymentStatePreparedStackProfileAzureGrant: DeploymentStatePreparedStackProfileAzureGrant): string;
+export declare function deploymentStatePreparedStackProfileAzureGrantFromJSON(jsonString: string): SafeParseResult<DeploymentStatePreparedStackProfileAzureGrant, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePreparedStackProfileAzure$inboundSchema: z.ZodType<DeploymentStatePreparedStackProfileAzure, unknown>;
+/** @internal */
+export type DeploymentStatePreparedStackProfileAzure$Outbound = {
+    binding: DeploymentStatePreparedStackProfileAzureBinding$Outbound;
+    description?: string | null | undefined;
+    grant: DeploymentStatePreparedStackProfileAzureGrant$Outbound;
+    label?: string | null | undefined;
+};
+/** @internal */
+export declare const DeploymentStatePreparedStackProfileAzure$outboundSchema: z.ZodType<DeploymentStatePreparedStackProfileAzure$Outbound, DeploymentStatePreparedStackProfileAzure>;
+export declare function deploymentStatePreparedStackProfileAzureToJSON(deploymentStatePreparedStackProfileAzure: DeploymentStatePreparedStackProfileAzure): string;
+export declare function deploymentStatePreparedStackProfileAzureFromJSON(jsonString: string): SafeParseResult<DeploymentStatePreparedStackProfileAzure, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePreparedStackProfileConditionResource$inboundSchema: z.ZodType<DeploymentStatePreparedStackProfileConditionResource, unknown>;
+/** @internal */
+export type DeploymentStatePreparedStackProfileConditionResource$Outbound = {
+    expression: string;
+    title: string;
+};
+/** @internal */
+export declare const DeploymentStatePreparedStackProfileConditionResource$outboundSchema: z.ZodType<DeploymentStatePreparedStackProfileConditionResource$Outbound, DeploymentStatePreparedStackProfileConditionResource>;
+export declare function deploymentStatePreparedStackProfileConditionResourceToJSON(deploymentStatePreparedStackProfileConditionResource: DeploymentStatePreparedStackProfileConditionResource): string;
+export declare function deploymentStatePreparedStackProfileConditionResourceFromJSON(jsonString: string): SafeParseResult<DeploymentStatePreparedStackProfileConditionResource, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePreparedStackProfileResourceConditionUnion$inboundSchema: z.ZodType<DeploymentStatePreparedStackProfileResourceConditionUnion, unknown>;
+/** @internal */
+export type DeploymentStatePreparedStackProfileResourceConditionUnion$Outbound = DeploymentStatePreparedStackProfileConditionResource$Outbound | string;
+/** @internal */
+export declare const DeploymentStatePreparedStackProfileResourceConditionUnion$outboundSchema: z.ZodType<DeploymentStatePreparedStackProfileResourceConditionUnion$Outbound, DeploymentStatePreparedStackProfileResourceConditionUnion>;
+export declare function deploymentStatePreparedStackProfileResourceConditionUnionToJSON(deploymentStatePreparedStackProfileResourceConditionUnion: DeploymentStatePreparedStackProfileResourceConditionUnion): string;
+export declare function deploymentStatePreparedStackProfileResourceConditionUnionFromJSON(jsonString: string): SafeParseResult<DeploymentStatePreparedStackProfileResourceConditionUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePreparedStackProfileGcpResource$inboundSchema: z.ZodType<DeploymentStatePreparedStackProfileGcpResource, unknown>;
+/** @internal */
+export type DeploymentStatePreparedStackProfileGcpResource$Outbound = {
+    condition?: DeploymentStatePreparedStackProfileConditionResource$Outbound | string | null | undefined;
+    scope: string;
+};
+/** @internal */
+export declare const DeploymentStatePreparedStackProfileGcpResource$outboundSchema: z.ZodType<DeploymentStatePreparedStackProfileGcpResource$Outbound, DeploymentStatePreparedStackProfileGcpResource>;
+export declare function deploymentStatePreparedStackProfileGcpResourceToJSON(deploymentStatePreparedStackProfileGcpResource: DeploymentStatePreparedStackProfileGcpResource): string;
+export declare function deploymentStatePreparedStackProfileGcpResourceFromJSON(jsonString: string): SafeParseResult<DeploymentStatePreparedStackProfileGcpResource, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePreparedStackProfileConditionStack$inboundSchema: z.ZodType<DeploymentStatePreparedStackProfileConditionStack, unknown>;
+/** @internal */
+export type DeploymentStatePreparedStackProfileConditionStack$Outbound = {
+    expression: string;
+    title: string;
+};
+/** @internal */
+export declare const DeploymentStatePreparedStackProfileConditionStack$outboundSchema: z.ZodType<DeploymentStatePreparedStackProfileConditionStack$Outbound, DeploymentStatePreparedStackProfileConditionStack>;
+export declare function deploymentStatePreparedStackProfileConditionStackToJSON(deploymentStatePreparedStackProfileConditionStack: DeploymentStatePreparedStackProfileConditionStack): string;
+export declare function deploymentStatePreparedStackProfileConditionStackFromJSON(jsonString: string): SafeParseResult<DeploymentStatePreparedStackProfileConditionStack, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePreparedStackProfileStackConditionUnion$inboundSchema: z.ZodType<DeploymentStatePreparedStackProfileStackConditionUnion, unknown>;
+/** @internal */
+export type DeploymentStatePreparedStackProfileStackConditionUnion$Outbound = DeploymentStatePreparedStackProfileConditionStack$Outbound | string;
+/** @internal */
+export declare const DeploymentStatePreparedStackProfileStackConditionUnion$outboundSchema: z.ZodType<DeploymentStatePreparedStackProfileStackConditionUnion$Outbound, DeploymentStatePreparedStackProfileStackConditionUnion>;
+export declare function deploymentStatePreparedStackProfileStackConditionUnionToJSON(deploymentStatePreparedStackProfileStackConditionUnion: DeploymentStatePreparedStackProfileStackConditionUnion): string;
+export declare function deploymentStatePreparedStackProfileStackConditionUnionFromJSON(jsonString: string): SafeParseResult<DeploymentStatePreparedStackProfileStackConditionUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePreparedStackProfileGcpStack$inboundSchema: z.ZodType<DeploymentStatePreparedStackProfileGcpStack, unknown>;
+/** @internal */
+export type DeploymentStatePreparedStackProfileGcpStack$Outbound = {
+    condition?: DeploymentStatePreparedStackProfileConditionStack$Outbound | string | null | undefined;
+    scope: string;
+};
+/** @internal */
+export declare const DeploymentStatePreparedStackProfileGcpStack$outboundSchema: z.ZodType<DeploymentStatePreparedStackProfileGcpStack$Outbound, DeploymentStatePreparedStackProfileGcpStack>;
+export declare function deploymentStatePreparedStackProfileGcpStackToJSON(deploymentStatePreparedStackProfileGcpStack: DeploymentStatePreparedStackProfileGcpStack): string;
+export declare function deploymentStatePreparedStackProfileGcpStackFromJSON(jsonString: string): SafeParseResult<DeploymentStatePreparedStackProfileGcpStack, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePreparedStackProfileGcpBinding$inboundSchema: z.ZodType<DeploymentStatePreparedStackProfileGcpBinding, unknown>;
+/** @internal */
+export type DeploymentStatePreparedStackProfileGcpBinding$Outbound = {
+    resource?: DeploymentStatePreparedStackProfileGcpResource$Outbound | undefined;
+    stack?: DeploymentStatePreparedStackProfileGcpStack$Outbound | undefined;
+};
+/** @internal */
+export declare const DeploymentStatePreparedStackProfileGcpBinding$outboundSchema: z.ZodType<DeploymentStatePreparedStackProfileGcpBinding$Outbound, DeploymentStatePreparedStackProfileGcpBinding>;
+export declare function deploymentStatePreparedStackProfileGcpBindingToJSON(deploymentStatePreparedStackProfileGcpBinding: DeploymentStatePreparedStackProfileGcpBinding): string;
+export declare function deploymentStatePreparedStackProfileGcpBindingFromJSON(jsonString: string): SafeParseResult<DeploymentStatePreparedStackProfileGcpBinding, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePreparedStackProfileGcpGrant$inboundSchema: z.ZodType<DeploymentStatePreparedStackProfileGcpGrant, unknown>;
+/** @internal */
+export type DeploymentStatePreparedStackProfileGcpGrant$Outbound = {
+    actions?: Array<string> | null | undefined;
+    dataActions?: Array<string> | null | undefined;
+    permissions?: Array<string> | null | undefined;
+    predefinedRoles?: Array<string> | null | undefined;
+    residualPermissions?: Array<string> | null | undefined;
+};
+/** @internal */
+export declare const DeploymentStatePreparedStackProfileGcpGrant$outboundSchema: z.ZodType<DeploymentStatePreparedStackProfileGcpGrant$Outbound, DeploymentStatePreparedStackProfileGcpGrant>;
+export declare function deploymentStatePreparedStackProfileGcpGrantToJSON(deploymentStatePreparedStackProfileGcpGrant: DeploymentStatePreparedStackProfileGcpGrant): string;
+export declare function deploymentStatePreparedStackProfileGcpGrantFromJSON(jsonString: string): SafeParseResult<DeploymentStatePreparedStackProfileGcpGrant, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePreparedStackProfileGcp$inboundSchema: z.ZodType<DeploymentStatePreparedStackProfileGcp, unknown>;
+/** @internal */
+export type DeploymentStatePreparedStackProfileGcp$Outbound = {
+    binding: DeploymentStatePreparedStackProfileGcpBinding$Outbound;
+    description?: string | null | undefined;
+    grant: DeploymentStatePreparedStackProfileGcpGrant$Outbound;
+    label?: string | null | undefined;
+};
+/** @internal */
+export declare const DeploymentStatePreparedStackProfileGcp$outboundSchema: z.ZodType<DeploymentStatePreparedStackProfileGcp$Outbound, DeploymentStatePreparedStackProfileGcp>;
+export declare function deploymentStatePreparedStackProfileGcpToJSON(deploymentStatePreparedStackProfileGcp: DeploymentStatePreparedStackProfileGcp): string;
+export declare function deploymentStatePreparedStackProfileGcpFromJSON(jsonString: string): SafeParseResult<DeploymentStatePreparedStackProfileGcp, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePreparedStackProfilePlatforms$inboundSchema: z.ZodType<DeploymentStatePreparedStackProfilePlatforms, unknown>;
+/** @internal */
+export type DeploymentStatePreparedStackProfilePlatforms$Outbound = {
+    aws?: Array<DeploymentStatePreparedStackProfileAw$Outbound> | null | undefined;
+    azure?: Array<DeploymentStatePreparedStackProfileAzure$Outbound> | null | undefined;
+    gcp?: Array<DeploymentStatePreparedStackProfileGcp$Outbound> | null | undefined;
+};
+/** @internal */
+export declare const DeploymentStatePreparedStackProfilePlatforms$outboundSchema: z.ZodType<DeploymentStatePreparedStackProfilePlatforms$Outbound, DeploymentStatePreparedStackProfilePlatforms>;
+export declare function deploymentStatePreparedStackProfilePlatformsToJSON(deploymentStatePreparedStackProfilePlatforms: DeploymentStatePreparedStackProfilePlatforms): string;
+export declare function deploymentStatePreparedStackProfilePlatformsFromJSON(jsonString: string): SafeParseResult<DeploymentStatePreparedStackProfilePlatforms, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePreparedStackProfile$inboundSchema: z.ZodType<DeploymentStatePreparedStackProfile, unknown>;
+/** @internal */
+export type DeploymentStatePreparedStackProfile$Outbound = {
+    description: string;
+    id: string;
+    platforms: DeploymentStatePreparedStackProfilePlatforms$Outbound;
+};
+/** @internal */
+export declare const DeploymentStatePreparedStackProfile$outboundSchema: z.ZodType<DeploymentStatePreparedStackProfile$Outbound, DeploymentStatePreparedStackProfile>;
+export declare function deploymentStatePreparedStackProfileToJSON(deploymentStatePreparedStackProfile: DeploymentStatePreparedStackProfile): string;
+export declare function deploymentStatePreparedStackProfileFromJSON(jsonString: string): SafeParseResult<DeploymentStatePreparedStackProfile, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePreparedStackProfileUnion$inboundSchema: z.ZodType<DeploymentStatePreparedStackProfileUnion, unknown>;
+/** @internal */
+export type DeploymentStatePreparedStackProfileUnion$Outbound = DeploymentStatePreparedStackProfile$Outbound | string;
+/** @internal */
+export declare const DeploymentStatePreparedStackProfileUnion$outboundSchema: z.ZodType<DeploymentStatePreparedStackProfileUnion$Outbound, DeploymentStatePreparedStackProfileUnion>;
+export declare function deploymentStatePreparedStackProfileUnionToJSON(deploymentStatePreparedStackProfileUnion: DeploymentStatePreparedStackProfileUnion): string;
+export declare function deploymentStatePreparedStackProfileUnionFromJSON(jsonString: string): SafeParseResult<DeploymentStatePreparedStackProfileUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePreparedStackPermissions$inboundSchema: z.ZodType<DeploymentStatePreparedStackPermissions, unknown>;
+/** @internal */
+export type DeploymentStatePreparedStackPermissions$Outbound = {
+    management?: DeploymentStatePreparedStackManagementUnion$Outbound | undefined;
+    profiles: {
+        [k: string]: {
+            [k: string]: Array<DeploymentStatePreparedStackProfile$Outbound | string>;
+        };
+    };
+};
+/** @internal */
+export declare const DeploymentStatePreparedStackPermissions$outboundSchema: z.ZodType<DeploymentStatePreparedStackPermissions$Outbound, DeploymentStatePreparedStackPermissions>;
+export declare function deploymentStatePreparedStackPermissionsToJSON(deploymentStatePreparedStackPermissions: DeploymentStatePreparedStackPermissions): string;
+export declare function deploymentStatePreparedStackPermissionsFromJSON(jsonString: string): SafeParseResult<DeploymentStatePreparedStackPermissions, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePreparedStackConfig$inboundSchema: z.ZodType<DeploymentStatePreparedStackConfig, unknown>;
+/** @internal */
+export type DeploymentStatePreparedStackConfig$Outbound = {
+    id: string;
+    type: string;
+    [additionalProperties: string]: unknown;
+};
+/** @internal */
+export declare const DeploymentStatePreparedStackConfig$outboundSchema: z.ZodType<DeploymentStatePreparedStackConfig$Outbound, DeploymentStatePreparedStackConfig>;
+export declare function deploymentStatePreparedStackConfigToJSON(deploymentStatePreparedStackConfig: DeploymentStatePreparedStackConfig): string;
+export declare function deploymentStatePreparedStackConfigFromJSON(jsonString: string): SafeParseResult<DeploymentStatePreparedStackConfig, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePreparedStackDependency$inboundSchema: z.ZodType<DeploymentStatePreparedStackDependency, unknown>;
+/** @internal */
+export type DeploymentStatePreparedStackDependency$Outbound = {
+    id: string;
+    type: string;
+};
+/** @internal */
+export declare const DeploymentStatePreparedStackDependency$outboundSchema: z.ZodType<DeploymentStatePreparedStackDependency$Outbound, DeploymentStatePreparedStackDependency>;
+export declare function deploymentStatePreparedStackDependencyToJSON(deploymentStatePreparedStackDependency: DeploymentStatePreparedStackDependency): string;
+export declare function deploymentStatePreparedStackDependencyFromJSON(jsonString: string): SafeParseResult<DeploymentStatePreparedStackDependency, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePreparedStackLifecycle$inboundSchema: z.ZodEnum<typeof DeploymentStatePreparedStackLifecycle>;
+/** @internal */
+export declare const DeploymentStatePreparedStackLifecycle$outboundSchema: z.ZodEnum<typeof DeploymentStatePreparedStackLifecycle>;
+/** @internal */
+export declare const DeploymentStatePreparedStackResources$inboundSchema: z.ZodType<DeploymentStatePreparedStackResources, unknown>;
+/** @internal */
+export type DeploymentStatePreparedStackResources$Outbound = {
+    config: DeploymentStatePreparedStackConfig$Outbound;
+    dependencies: Array<DeploymentStatePreparedStackDependency$Outbound>;
+    enabledWhen?: string | null | undefined;
+    lifecycle: string;
+    remoteAccess?: boolean | undefined;
+};
+/** @internal */
+export declare const DeploymentStatePreparedStackResources$outboundSchema: z.ZodType<DeploymentStatePreparedStackResources$Outbound, DeploymentStatePreparedStackResources>;
+export declare function deploymentStatePreparedStackResourcesToJSON(deploymentStatePreparedStackResources: DeploymentStatePreparedStackResources): string;
+export declare function deploymentStatePreparedStackResourcesFromJSON(jsonString: string): SafeParseResult<DeploymentStatePreparedStackResources, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePreparedStackSupportedPlatform$inboundSchema: z.ZodEnum<typeof DeploymentStatePreparedStackSupportedPlatform>;
+/** @internal */
+export declare const DeploymentStatePreparedStackSupportedPlatform$outboundSchema: z.ZodEnum<typeof DeploymentStatePreparedStackSupportedPlatform>;
+/** @internal */
+export declare const DeploymentStatePreparedStack$inboundSchema: z.ZodType<DeploymentStatePreparedStack, unknown>;
+/** @internal */
+export type DeploymentStatePreparedStack$Outbound = {
+    dynamicContainerImageResources?: Array<string> | undefined;
+    dynamicContainerRepositories?: Array<string> | undefined;
+    id: string;
+    inputs?: Array<DeploymentStatePreparedStackInput$Outbound> | undefined;
+    permissions?: DeploymentStatePreparedStackPermissions$Outbound | undefined;
+    resources: {
+        [k: string]: DeploymentStatePreparedStackResources$Outbound;
+    };
+    supportedPlatforms?: Array<string> | null | undefined;
+};
+/** @internal */
+export declare const DeploymentStatePreparedStack$outboundSchema: z.ZodType<DeploymentStatePreparedStack$Outbound, DeploymentStatePreparedStack>;
+export declare function deploymentStatePreparedStackToJSON(deploymentStatePreparedStack: DeploymentStatePreparedStack): string;
+export declare function deploymentStatePreparedStackFromJSON(jsonString: string): SafeParseResult<DeploymentStatePreparedStack, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePreparedStackUnion$inboundSchema: z.ZodType<DeploymentStatePreparedStackUnion, unknown>;
+/** @internal */
+export type DeploymentStatePreparedStackUnion$Outbound = DeploymentStatePreparedStack$Outbound | string;
+/** @internal */
+export declare const DeploymentStatePreparedStackUnion$outboundSchema: z.ZodType<DeploymentStatePreparedStackUnion$Outbound, DeploymentStatePreparedStackUnion>;
+export declare function deploymentStatePreparedStackUnionToJSON(deploymentStatePreparedStackUnion: DeploymentStatePreparedStackUnion): string;
+export declare function deploymentStatePreparedStackUnionFromJSON(jsonString: string): SafeParseResult<DeploymentStatePreparedStackUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateRegistryAccess$inboundSchema: z.ZodType<DeploymentStateRegistryAccess, unknown>;
+/** @internal */
+export type DeploymentStateRegistryAccess$Outbound = {
+    repositories?: Array<string> | undefined;
+    serviceTypes?: Array<string> | undefined;
+};
+/** @internal */
+export declare const DeploymentStateRegistryAccess$outboundSchema: z.ZodType<DeploymentStateRegistryAccess$Outbound, DeploymentStateRegistryAccess>;
+export declare function deploymentStateRegistryAccessToJSON(deploymentStateRegistryAccess: DeploymentStateRegistryAccess): string;
+export declare function deploymentStateRegistryAccessFromJSON(jsonString: string): SafeParseResult<DeploymentStateRegistryAccess, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateRegistryAccessUnion$inboundSchema: z.ZodType<DeploymentStateRegistryAccessUnion, unknown>;
+/** @internal */
+export type DeploymentStateRegistryAccessUnion$Outbound = DeploymentStateRegistryAccess$Outbound | string;
+/** @internal */
+export declare const DeploymentStateRegistryAccessUnion$outboundSchema: z.ZodType<DeploymentStateRegistryAccessUnion$Outbound, DeploymentStateRegistryAccessUnion>;
+export declare function deploymentStateRegistryAccessUnionToJSON(deploymentStateRegistryAccessUnion: DeploymentStateRegistryAccessUnion): string;
+export declare function deploymentStateRegistryAccessUnionFromJSON(jsonString: string): SafeParseResult<DeploymentStateRegistryAccessUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateEgress$inboundSchema: z.ZodType<DeploymentStateEgress, unknown>;
+/** @internal */
+export type DeploymentStateEgress$Outbound = {
+    connectorArn?: string | null | undefined;
+    connectorRequest?: string | null | undefined;
+    operatorRoleName: string;
+    securityGroupId?: string | null | undefined;
+};
+/** @internal */
+export declare const DeploymentStateEgress$outboundSchema: z.ZodType<DeploymentStateEgress$Outbound, DeploymentStateEgress>;
+export declare function deploymentStateEgressToJSON(deploymentStateEgress: DeploymentStateEgress): string;
+export declare function deploymentStateEgressFromJSON(jsonString: string): SafeParseResult<DeploymentStateEgress, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateEgressUnion$inboundSchema: z.ZodType<DeploymentStateEgressUnion, unknown>;
+/** @internal */
+export type DeploymentStateEgressUnion$Outbound = DeploymentStateEgress$Outbound | string;
+/** @internal */
+export declare const DeploymentStateEgressUnion$outboundSchema: z.ZodType<DeploymentStateEgressUnion$Outbound, DeploymentStateEgressUnion>;
+export declare function deploymentStateEgressUnionToJSON(deploymentStateEgressUnion: DeploymentStateEgressUnion): string;
+export declare function deploymentStateEgressUnionFromJSON(jsonString: string): SafeParseResult<DeploymentStateEgressUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateTypeAwsSandbox$inboundSchema: z.ZodEnum<typeof DeploymentStateTypeAwsSandbox>;
+/** @internal */
+export declare const DeploymentStateTypeAwsSandbox$outboundSchema: z.ZodEnum<typeof DeploymentStateTypeAwsSandbox>;
+/** @internal */
+export declare const DeploymentStateSetupScaffolding$inboundSchema: z.ZodType<DeploymentStateSetupScaffolding, unknown>;
+/** @internal */
+export type DeploymentStateSetupScaffolding$Outbound = {
+    buildRoleName: string;
+    egress?: DeploymentStateEgress$Outbound | string | null | undefined;
+    imageArn?: string | null | undefined;
+    type: string;
+};
+/** @internal */
+export declare const DeploymentStateSetupScaffolding$outboundSchema: z.ZodType<DeploymentStateSetupScaffolding$Outbound, DeploymentStateSetupScaffolding>;
+export declare function deploymentStateSetupScaffoldingToJSON(deploymentStateSetupScaffolding: DeploymentStateSetupScaffolding): string;
+export declare function deploymentStateSetupScaffoldingFromJSON(jsonString: string): SafeParseResult<DeploymentStateSetupScaffolding, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateSetupUpdateAuthorization$inboundSchema: z.ZodType<DeploymentStateSetupUpdateAuthorization, unknown>;
+/** @internal */
+export type DeploymentStateSetupUpdateAuthorization$Outbound = {
+    baselineFrozenDigest: string;
+    nonce: string;
+    releaseId: string;
+    setupFingerprint: string;
+    setupFingerprintVersion: number;
+    setupTarget: string;
+    targetFrozenDigest: string;
+};
+/** @internal */
+export declare const DeploymentStateSetupUpdateAuthorization$outboundSchema: z.ZodType<DeploymentStateSetupUpdateAuthorization$Outbound, DeploymentStateSetupUpdateAuthorization>;
+export declare function deploymentStateSetupUpdateAuthorizationToJSON(deploymentStateSetupUpdateAuthorization: DeploymentStateSetupUpdateAuthorization): string;
+export declare function deploymentStateSetupUpdateAuthorizationFromJSON(jsonString: string): SafeParseResult<DeploymentStateSetupUpdateAuthorization, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateSetupUpdateAuthorizationUnion$inboundSchema: z.ZodType<DeploymentStateSetupUpdateAuthorizationUnion, unknown>;
+/** @internal */
+export type DeploymentStateSetupUpdateAuthorizationUnion$Outbound = DeploymentStateSetupUpdateAuthorization$Outbound | string;
+/** @internal */
+export declare const DeploymentStateSetupUpdateAuthorizationUnion$outboundSchema: z.ZodType<DeploymentStateSetupUpdateAuthorizationUnion$Outbound, DeploymentStateSetupUpdateAuthorizationUnion>;
+export declare function deploymentStateSetupUpdateAuthorizationUnionToJSON(deploymentStateSetupUpdateAuthorizationUnion: DeploymentStateSetupUpdateAuthorizationUnion): string;
+export declare function deploymentStateSetupUpdateAuthorizationUnionFromJSON(jsonString: string): SafeParseResult<DeploymentStateSetupUpdateAuthorizationUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateRuntimeMetadata$inboundSchema: z.ZodType<DeploymentStateRuntimeMetadata, unknown>;
+/** @internal */
+export type DeploymentStateRuntimeMetadata$Outbound = {
+    deployerSecrets?: Array<DeploymentStateDeployerSecret$Outbound> | undefined;
+    directSetupRevision?: string | null | undefined;
+    initialSetupAuthority?: string | undefined;
+    lastSyncedEnvVarsHash?: string | null | undefined;
+    lastSyncedSecretNames?: Array<string> | undefined;
+    pendingPreparedReleaseId?: string | null | undefined;
+    pendingPreparedStack?: DeploymentStatePendingPreparedStackUnion$Outbound | null | undefined;
+    persistedGateAnswers?: {
+        [k: string]: boolean;
+    } | undefined;
+    preparedStack?: DeploymentStatePreparedStack$Outbound | string | null | undefined;
+    registryAccess?: DeploymentStateRegistryAccess$Outbound | string | null | undefined;
+    registryAccessGranted?: boolean | undefined;
+    setupScaffolding?: {
+        [k: string]: DeploymentStateSetupScaffolding$Outbound;
+    } | undefined;
+    setupUpdateAuthorization?: DeploymentStateSetupUpdateAuthorization$Outbound | string | null | undefined;
+};
+/** @internal */
+export declare const DeploymentStateRuntimeMetadata$outboundSchema: z.ZodType<DeploymentStateRuntimeMetadata$Outbound, DeploymentStateRuntimeMetadata>;
+export declare function deploymentStateRuntimeMetadataToJSON(deploymentStateRuntimeMetadata: DeploymentStateRuntimeMetadata): string;
+export declare function deploymentStateRuntimeMetadataFromJSON(jsonString: string): SafeParseResult<DeploymentStateRuntimeMetadata, SDKValidationError>;
+/** @internal */
+export declare const RuntimeMetadata$inboundSchema: z.ZodType<RuntimeMetadata, unknown>;
+/** @internal */
+export type RuntimeMetadata$Outbound = DeploymentStateRuntimeMetadata$Outbound | string;
+/** @internal */
+export declare const RuntimeMetadata$outboundSchema: z.ZodType<RuntimeMetadata$Outbound, RuntimeMetadata>;
+export declare function runtimeMetadataToJSON(runtimeMetadata: RuntimeMetadata): string;
+export declare function runtimeMetadataFromJSON(jsonString: string): SafeParseResult<RuntimeMetadata, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateStackStatePlatform$inboundSchema: z.ZodEnum<typeof DeploymentStateStackStatePlatform>;
+/** @internal */
+export declare const DeploymentStateStackStatePlatform$outboundSchema: z.ZodEnum<typeof DeploymentStateStackStatePlatform>;
+/** @internal */
+export declare const DeploymentStateStackStateConfig$inboundSchema: z.ZodType<DeploymentStateStackStateConfig, unknown>;
+/** @internal */
+export type DeploymentStateStackStateConfig$Outbound = {
+    id: string;
+    type: string;
+    [additionalProperties: string]: unknown;
+};
+/** @internal */
+export declare const DeploymentStateStackStateConfig$outboundSchema: z.ZodType<DeploymentStateStackStateConfig$Outbound, DeploymentStateStackStateConfig>;
+export declare function deploymentStateStackStateConfigToJSON(deploymentStateStackStateConfig: DeploymentStateStackStateConfig): string;
+export declare function deploymentStateStackStateConfigFromJSON(jsonString: string): SafeParseResult<DeploymentStateStackStateConfig, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateControllerPlatformEnum$inboundSchema: z.ZodEnum<typeof DeploymentStateControllerPlatformEnum>;
+/** @internal */
+export declare const DeploymentStateControllerPlatformEnum$outboundSchema: z.ZodEnum<typeof DeploymentStateControllerPlatformEnum>;
+/** @internal */
+export declare const DeploymentStateControllerPlatformUnion$inboundSchema: z.ZodType<DeploymentStateControllerPlatformUnion, unknown>;
+/** @internal */
+export type DeploymentStateControllerPlatformUnion$Outbound = string | string;
+/** @internal */
+export declare const DeploymentStateControllerPlatformUnion$outboundSchema: z.ZodType<DeploymentStateControllerPlatformUnion$Outbound, DeploymentStateControllerPlatformUnion>;
+export declare function deploymentStateControllerPlatformUnionToJSON(deploymentStateControllerPlatformUnion: DeploymentStateControllerPlatformUnion): string;
+export declare function deploymentStateControllerPlatformUnionFromJSON(jsonString: string): SafeParseResult<DeploymentStateControllerPlatformUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateStackStateDependency$inboundSchema: z.ZodType<DeploymentStateStackStateDependency, unknown>;
+/** @internal */
+export type DeploymentStateStackStateDependency$Outbound = {
+    id: string;
+    type: string;
+};
+/** @internal */
+export declare const DeploymentStateStackStateDependency$outboundSchema: z.ZodType<DeploymentStateStackStateDependency$Outbound, DeploymentStateStackStateDependency>;
+export declare function deploymentStateStackStateDependencyToJSON(deploymentStateStackStateDependency: DeploymentStateStackStateDependency): string;
+export declare function deploymentStateStackStateDependencyFromJSON(jsonString: string): SafeParseResult<DeploymentStateStackStateDependency, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateStackStateError$inboundSchema: z.ZodType<DeploymentStateStackStateError, unknown>;
+/** @internal */
+export type DeploymentStateStackStateError$Outbound = {
+    code: string;
+    context?: any | null | undefined;
+    hint?: string | null | undefined;
+    httpStatusCode?: number | null | undefined;
+    internal: boolean;
+    message: string;
+    retryable: boolean;
+    source?: any | null | undefined;
+};
+/** @internal */
+export declare const DeploymentStateStackStateError$outboundSchema: z.ZodType<DeploymentStateStackStateError$Outbound, DeploymentStateStackStateError>;
+export declare function deploymentStateStackStateErrorToJSON(deploymentStateStackStateError: DeploymentStateStackStateError): string;
+export declare function deploymentStateStackStateErrorFromJSON(jsonString: string): SafeParseResult<DeploymentStateStackStateError, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateStackStateErrorUnion$inboundSchema: z.ZodType<DeploymentStateStackStateErrorUnion, unknown>;
+/** @internal */
+export type DeploymentStateStackStateErrorUnion$Outbound = DeploymentStateStackStateError$Outbound | string;
+/** @internal */
+export declare const DeploymentStateStackStateErrorUnion$outboundSchema: z.ZodType<DeploymentStateStackStateErrorUnion$Outbound, DeploymentStateStackStateErrorUnion>;
+export declare function deploymentStateStackStateErrorUnionToJSON(deploymentStateStackStateErrorUnion: DeploymentStateStackStateErrorUnion): string;
+export declare function deploymentStateStackStateErrorUnionFromJSON(jsonString: string): SafeParseResult<DeploymentStateStackStateErrorUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateStackStateLifecycleEnum$inboundSchema: z.ZodEnum<typeof DeploymentStateStackStateLifecycleEnum>;
+/** @internal */
+export declare const DeploymentStateStackStateLifecycleEnum$outboundSchema: z.ZodEnum<typeof DeploymentStateStackStateLifecycleEnum>;
+/** @internal */
+export declare const DeploymentStateLifecycleUnion$inboundSchema: z.ZodType<DeploymentStateLifecycleUnion, unknown>;
+/** @internal */
+export type DeploymentStateLifecycleUnion$Outbound = string | string;
+/** @internal */
+export declare const DeploymentStateLifecycleUnion$outboundSchema: z.ZodType<DeploymentStateLifecycleUnion$Outbound, DeploymentStateLifecycleUnion>;
+export declare function deploymentStateLifecycleUnionToJSON(deploymentStateLifecycleUnion: DeploymentStateLifecycleUnion): string;
+export declare function deploymentStateLifecycleUnionFromJSON(jsonString: string): SafeParseResult<DeploymentStateLifecycleUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateOutputs$inboundSchema: z.ZodType<DeploymentStateOutputs, unknown>;
+/** @internal */
+export type DeploymentStateOutputs$Outbound = {
+    type: string;
+    [additionalProperties: string]: unknown;
+};
+/** @internal */
+export declare const DeploymentStateOutputs$outboundSchema: z.ZodType<DeploymentStateOutputs$Outbound, DeploymentStateOutputs>;
+export declare function deploymentStateOutputsToJSON(deploymentStateOutputs: DeploymentStateOutputs): string;
+export declare function deploymentStateOutputsFromJSON(jsonString: string): SafeParseResult<DeploymentStateOutputs, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateOutputsUnion$inboundSchema: z.ZodType<DeploymentStateOutputsUnion, unknown>;
+/** @internal */
+export type DeploymentStateOutputsUnion$Outbound = DeploymentStateOutputs$Outbound | string;
+/** @internal */
+export declare const DeploymentStateOutputsUnion$outboundSchema: z.ZodType<DeploymentStateOutputsUnion$Outbound, DeploymentStateOutputsUnion>;
+export declare function deploymentStateOutputsUnionToJSON(deploymentStateOutputsUnion: DeploymentStateOutputsUnion): string;
+export declare function deploymentStateOutputsUnionFromJSON(jsonString: string): SafeParseResult<DeploymentStateOutputsUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePreviousConfig$inboundSchema: z.ZodType<DeploymentStatePreviousConfig, unknown>;
+/** @internal */
+export type DeploymentStatePreviousConfig$Outbound = {
+    id: string;
+    type: string;
+    [additionalProperties: string]: unknown;
+};
+/** @internal */
+export declare const DeploymentStatePreviousConfig$outboundSchema: z.ZodType<DeploymentStatePreviousConfig$Outbound, DeploymentStatePreviousConfig>;
+export declare function deploymentStatePreviousConfigToJSON(deploymentStatePreviousConfig: DeploymentStatePreviousConfig): string;
+export declare function deploymentStatePreviousConfigFromJSON(jsonString: string): SafeParseResult<DeploymentStatePreviousConfig, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePreviousConfigUnion$inboundSchema: z.ZodType<DeploymentStatePreviousConfigUnion, unknown>;
+/** @internal */
+export type DeploymentStatePreviousConfigUnion$Outbound = DeploymentStatePreviousConfig$Outbound | string;
+/** @internal */
+export declare const DeploymentStatePreviousConfigUnion$outboundSchema: z.ZodType<DeploymentStatePreviousConfigUnion$Outbound, DeploymentStatePreviousConfigUnion>;
+export declare function deploymentStatePreviousConfigUnionToJSON(deploymentStatePreviousConfigUnion: DeploymentStatePreviousConfigUnion): string;
+export declare function deploymentStatePreviousConfigUnionFromJSON(jsonString: string): SafeParseResult<DeploymentStatePreviousConfigUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateStackStateStatus$inboundSchema: z.ZodEnum<typeof DeploymentStateStackStateStatus>;
+/** @internal */
+export declare const DeploymentStateStackStateStatus$outboundSchema: z.ZodEnum<typeof DeploymentStateStackStateStatus>;
+/** @internal */
+export declare const DeploymentStateStackStateResources$inboundSchema: z.ZodType<DeploymentStateStackStateResources, unknown>;
+/** @internal */
+export type DeploymentStateStackStateResources$Outbound = {
+    _internal?: any | null | undefined;
+    config: DeploymentStateStackStateConfig$Outbound;
+    controllerPlatform?: string | string | null | undefined;
+    dependencies?: Array<DeploymentStateStackStateDependency$Outbound> | undefined;
+    error?: DeploymentStateStackStateError$Outbound | string | null | undefined;
+    lastFailedState?: any | null | undefined;
+    lifecycle?: string | string | null | undefined;
+    outputs?: DeploymentStateOutputs$Outbound | string | null | undefined;
+    previousConfig?: DeploymentStatePreviousConfig$Outbound | string | null | undefined;
+    remoteBindingParams?: any | null | undefined;
+    retryAttempt?: number | undefined;
+    status: string;
+    type: string;
+};
+/** @internal */
+export declare const DeploymentStateStackStateResources$outboundSchema: z.ZodType<DeploymentStateStackStateResources$Outbound, DeploymentStateStackStateResources>;
+export declare function deploymentStateStackStateResourcesToJSON(deploymentStateStackStateResources: DeploymentStateStackStateResources): string;
+export declare function deploymentStateStackStateResourcesFromJSON(jsonString: string): SafeParseResult<DeploymentStateStackStateResources, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateStackState$inboundSchema: z.ZodType<DeploymentStateStackState, unknown>;
+/** @internal */
+export type DeploymentStateStackState$Outbound = {
+    platform: string;
+    resourcePrefix: string;
+    resources: {
+        [k: string]: DeploymentStateStackStateResources$Outbound;
+    };
+};
+/** @internal */
+export declare const DeploymentStateStackState$outboundSchema: z.ZodType<DeploymentStateStackState$Outbound, DeploymentStateStackState>;
+export declare function deploymentStateStackStateToJSON(deploymentStateStackState: DeploymentStateStackState): string;
+export declare function deploymentStateStackStateFromJSON(jsonString: string): SafeParseResult<DeploymentStateStackState, SDKValidationError>;
+/** @internal */
+export declare const StackState$inboundSchema: z.ZodType<StackState, unknown>;
+/** @internal */
+export type StackState$Outbound = DeploymentStateStackState$Outbound | string;
+/** @internal */
+export declare const StackState$outboundSchema: z.ZodType<StackState$Outbound, StackState>;
+export declare function stackStateToJSON(stackState: StackState): string;
+export declare function stackStateFromJSON(jsonString: string): SafeParseResult<StackState, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateStatus$inboundSchema: z.ZodEnum<typeof DeploymentStateStatus>;
+/** @internal */
+export declare const DeploymentStateStatus$outboundSchema: z.ZodEnum<typeof DeploymentStateStatus>;
+/** @internal */
+export declare const TargetReleaseTypeStringList$inboundSchema: z.ZodEnum<typeof TargetReleaseTypeStringList>;
+/** @internal */
+export declare const TargetReleaseTypeStringList$outboundSchema: z.ZodEnum<typeof TargetReleaseTypeStringList>;
+/** @internal */
+export declare const TargetReleaseDefaultStringList$inboundSchema: z.ZodType<TargetReleaseDefaultStringList, unknown>;
+/** @internal */
+export type TargetReleaseDefaultStringList$Outbound = {
+    type: string;
+    value: Array<string>;
+};
+/** @internal */
+export declare const TargetReleaseDefaultStringList$outboundSchema: z.ZodType<TargetReleaseDefaultStringList$Outbound, TargetReleaseDefaultStringList>;
+export declare function targetReleaseDefaultStringListToJSON(targetReleaseDefaultStringList: TargetReleaseDefaultStringList): string;
+export declare function targetReleaseDefaultStringListFromJSON(jsonString: string): SafeParseResult<TargetReleaseDefaultStringList, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseTypeBoolean$inboundSchema: z.ZodEnum<typeof TargetReleaseTypeBoolean>;
+/** @internal */
+export declare const TargetReleaseTypeBoolean$outboundSchema: z.ZodEnum<typeof TargetReleaseTypeBoolean>;
+/** @internal */
+export declare const TargetReleaseDefaultBoolean$inboundSchema: z.ZodType<TargetReleaseDefaultBoolean, unknown>;
+/** @internal */
+export type TargetReleaseDefaultBoolean$Outbound = {
+    type: string;
+    value: boolean;
+};
+/** @internal */
+export declare const TargetReleaseDefaultBoolean$outboundSchema: z.ZodType<TargetReleaseDefaultBoolean$Outbound, TargetReleaseDefaultBoolean>;
+export declare function targetReleaseDefaultBooleanToJSON(targetReleaseDefaultBoolean: TargetReleaseDefaultBoolean): string;
+export declare function targetReleaseDefaultBooleanFromJSON(jsonString: string): SafeParseResult<TargetReleaseDefaultBoolean, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseTypeNumber$inboundSchema: z.ZodEnum<typeof TargetReleaseTypeNumber>;
+/** @internal */
+export declare const TargetReleaseTypeNumber$outboundSchema: z.ZodEnum<typeof TargetReleaseTypeNumber>;
+/** @internal */
+export declare const TargetReleaseDefaultNumber$inboundSchema: z.ZodType<TargetReleaseDefaultNumber, unknown>;
+/** @internal */
+export type TargetReleaseDefaultNumber$Outbound = {
+    type: string;
+    value: string;
+};
+/** @internal */
+export declare const TargetReleaseDefaultNumber$outboundSchema: z.ZodType<TargetReleaseDefaultNumber$Outbound, TargetReleaseDefaultNumber>;
+export declare function targetReleaseDefaultNumberToJSON(targetReleaseDefaultNumber: TargetReleaseDefaultNumber): string;
+export declare function targetReleaseDefaultNumberFromJSON(jsonString: string): SafeParseResult<TargetReleaseDefaultNumber, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseTypeString$inboundSchema: z.ZodEnum<typeof TargetReleaseTypeString>;
+/** @internal */
+export declare const TargetReleaseTypeString$outboundSchema: z.ZodEnum<typeof TargetReleaseTypeString>;
+/** @internal */
+export declare const TargetReleaseDefaultString$inboundSchema: z.ZodType<TargetReleaseDefaultString, unknown>;
+/** @internal */
+export type TargetReleaseDefaultString$Outbound = {
+    type: string;
+    value: string;
+};
+/** @internal */
+export declare const TargetReleaseDefaultString$outboundSchema: z.ZodType<TargetReleaseDefaultString$Outbound, TargetReleaseDefaultString>;
+export declare function targetReleaseDefaultStringToJSON(targetReleaseDefaultString: TargetReleaseDefaultString): string;
+export declare function targetReleaseDefaultStringFromJSON(jsonString: string): SafeParseResult<TargetReleaseDefaultString, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseDefaultUnion$inboundSchema: z.ZodType<TargetReleaseDefaultUnion, unknown>;
+/** @internal */
+export type TargetReleaseDefaultUnion$Outbound = TargetReleaseDefaultString$Outbound | TargetReleaseDefaultNumber$Outbound | TargetReleaseDefaultBoolean$Outbound | TargetReleaseDefaultStringList$Outbound | string;
+/** @internal */
+export declare const TargetReleaseDefaultUnion$outboundSchema: z.ZodType<TargetReleaseDefaultUnion$Outbound, TargetReleaseDefaultUnion>;
+export declare function targetReleaseDefaultUnionToJSON(targetReleaseDefaultUnion: TargetReleaseDefaultUnion): string;
+export declare function targetReleaseDefaultUnionFromJSON(jsonString: string): SafeParseResult<TargetReleaseDefaultUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseTypeEnvEnum$inboundSchema: z.ZodEnum<typeof TargetReleaseTypeEnvEnum>;
+/** @internal */
+export declare const TargetReleaseTypeEnvEnum$outboundSchema: z.ZodEnum<typeof TargetReleaseTypeEnvEnum>;
+/** @internal */
+export declare const TargetReleaseTypeUnion$inboundSchema: z.ZodType<TargetReleaseTypeUnion, unknown>;
+/** @internal */
+export type TargetReleaseTypeUnion$Outbound = string | string;
+/** @internal */
+export declare const TargetReleaseTypeUnion$outboundSchema: z.ZodType<TargetReleaseTypeUnion$Outbound, TargetReleaseTypeUnion>;
+export declare function targetReleaseTypeUnionToJSON(targetReleaseTypeUnion: TargetReleaseTypeUnion): string;
+export declare function targetReleaseTypeUnionFromJSON(jsonString: string): SafeParseResult<TargetReleaseTypeUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseEnv$inboundSchema: z.ZodType<TargetReleaseEnv, unknown>;
+/** @internal */
+export type TargetReleaseEnv$Outbound = {
+    name: string;
+    targetResources?: Array<string> | null | undefined;
+    type?: string | string | null | undefined;
+};
+/** @internal */
+export declare const TargetReleaseEnv$outboundSchema: z.ZodType<TargetReleaseEnv$Outbound, TargetReleaseEnv>;
+export declare function targetReleaseEnvToJSON(targetReleaseEnv: TargetReleaseEnv): string;
+export declare function targetReleaseEnvFromJSON(jsonString: string): SafeParseResult<TargetReleaseEnv, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseGenerate$inboundSchema: z.ZodType<TargetReleaseGenerate, unknown>;
+/** @internal */
+export type TargetReleaseGenerate$Outbound = {
+    length: number;
+};
+/** @internal */
+export declare const TargetReleaseGenerate$outboundSchema: z.ZodType<TargetReleaseGenerate$Outbound, TargetReleaseGenerate>;
+export declare function targetReleaseGenerateToJSON(targetReleaseGenerate: TargetReleaseGenerate): string;
+export declare function targetReleaseGenerateFromJSON(jsonString: string): SafeParseResult<TargetReleaseGenerate, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseGenerateUnion$inboundSchema: z.ZodType<TargetReleaseGenerateUnion, unknown>;
+/** @internal */
+export type TargetReleaseGenerateUnion$Outbound = TargetReleaseGenerate$Outbound | string;
+/** @internal */
+export declare const TargetReleaseGenerateUnion$outboundSchema: z.ZodType<TargetReleaseGenerateUnion$Outbound, TargetReleaseGenerateUnion>;
+export declare function targetReleaseGenerateUnionToJSON(targetReleaseGenerateUnion: TargetReleaseGenerateUnion): string;
+export declare function targetReleaseGenerateUnionFromJSON(jsonString: string): SafeParseResult<TargetReleaseGenerateUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseKind$inboundSchema: z.ZodEnum<typeof TargetReleaseKind>;
+/** @internal */
+export declare const TargetReleaseKind$outboundSchema: z.ZodEnum<typeof TargetReleaseKind>;
+/** @internal */
+export declare const TargetReleasePlatform$inboundSchema: z.ZodEnum<typeof TargetReleasePlatform>;
+/** @internal */
+export declare const TargetReleasePlatform$outboundSchema: z.ZodEnum<typeof TargetReleasePlatform>;
+/** @internal */
+export declare const TargetReleaseProvidedBy$inboundSchema: z.ZodEnum<typeof TargetReleaseProvidedBy>;
+/** @internal */
+export declare const TargetReleaseProvidedBy$outboundSchema: z.ZodEnum<typeof TargetReleaseProvidedBy>;
+/** @internal */
+export declare const TargetReleaseValidation$inboundSchema: z.ZodType<TargetReleaseValidation, unknown>;
+/** @internal */
+export type TargetReleaseValidation$Outbound = {
+    format?: string | null | undefined;
+    max?: string | null | undefined;
+    maxItems?: number | null | undefined;
+    maxLength?: number | null | undefined;
+    min?: string | null | undefined;
+    minItems?: number | null | undefined;
+    minLength?: number | null | undefined;
+    pattern?: string | null | undefined;
+    values?: Array<string> | null | undefined;
+};
+/** @internal */
+export declare const TargetReleaseValidation$outboundSchema: z.ZodType<TargetReleaseValidation$Outbound, TargetReleaseValidation>;
+export declare function targetReleaseValidationToJSON(targetReleaseValidation: TargetReleaseValidation): string;
+export declare function targetReleaseValidationFromJSON(jsonString: string): SafeParseResult<TargetReleaseValidation, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseValidationUnion$inboundSchema: z.ZodType<TargetReleaseValidationUnion, unknown>;
+/** @internal */
+export type TargetReleaseValidationUnion$Outbound = TargetReleaseValidation$Outbound | string;
+/** @internal */
+export declare const TargetReleaseValidationUnion$outboundSchema: z.ZodType<TargetReleaseValidationUnion$Outbound, TargetReleaseValidationUnion>;
+export declare function targetReleaseValidationUnionToJSON(targetReleaseValidationUnion: TargetReleaseValidationUnion): string;
+export declare function targetReleaseValidationUnionFromJSON(jsonString: string): SafeParseResult<TargetReleaseValidationUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseInput$inboundSchema: z.ZodType<TargetReleaseInput, unknown>;
+/** @internal */
+export type TargetReleaseInput$Outbound = {
+    default?: TargetReleaseDefaultString$Outbound | TargetReleaseDefaultNumber$Outbound | TargetReleaseDefaultBoolean$Outbound | TargetReleaseDefaultStringList$Outbound | string | null | undefined;
+    description: string;
+    env?: Array<TargetReleaseEnv$Outbound> | undefined;
+    generate?: TargetReleaseGenerate$Outbound | string | null | undefined;
+    id: string;
+    kind: string;
+    label: string;
+    placeholder?: string | null | undefined;
+    platforms?: Array<string> | null | undefined;
+    providedBy: Array<string>;
+    required: boolean;
+    validation?: TargetReleaseValidation$Outbound | string | null | undefined;
+};
+/** @internal */
+export declare const TargetReleaseInput$outboundSchema: z.ZodType<TargetReleaseInput$Outbound, TargetReleaseInput>;
+export declare function targetReleaseInputToJSON(targetReleaseInput: TargetReleaseInput): string;
+export declare function targetReleaseInputFromJSON(jsonString: string): SafeParseResult<TargetReleaseInput, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseManagementEnum$inboundSchema: z.ZodEnum<typeof TargetReleaseManagementEnum>;
+/** @internal */
+export declare const TargetReleaseManagementEnum$outboundSchema: z.ZodEnum<typeof TargetReleaseManagementEnum>;
+/** @internal */
+export declare const TargetReleaseOverrideAwResource$inboundSchema: z.ZodType<TargetReleaseOverrideAwResource, unknown>;
+/** @internal */
+export type TargetReleaseOverrideAwResource$Outbound = {
+    condition?: {
+        [k: string]: {
+            [k: string]: string;
+        };
+    } | null | undefined;
+    notResources?: Array<string> | undefined;
+    resources: Array<string>;
+};
+/** @internal */
+export declare const TargetReleaseOverrideAwResource$outboundSchema: z.ZodType<TargetReleaseOverrideAwResource$Outbound, TargetReleaseOverrideAwResource>;
+export declare function targetReleaseOverrideAwResourceToJSON(targetReleaseOverrideAwResource: TargetReleaseOverrideAwResource): string;
+export declare function targetReleaseOverrideAwResourceFromJSON(jsonString: string): SafeParseResult<TargetReleaseOverrideAwResource, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseOverrideAwStack$inboundSchema: z.ZodType<TargetReleaseOverrideAwStack, unknown>;
+/** @internal */
+export type TargetReleaseOverrideAwStack$Outbound = {
+    condition?: {
+        [k: string]: {
+            [k: string]: string;
+        };
+    } | null | undefined;
+    notResources?: Array<string> | undefined;
+    resources: Array<string>;
+};
+/** @internal */
+export declare const TargetReleaseOverrideAwStack$outboundSchema: z.ZodType<TargetReleaseOverrideAwStack$Outbound, TargetReleaseOverrideAwStack>;
+export declare function targetReleaseOverrideAwStackToJSON(targetReleaseOverrideAwStack: TargetReleaseOverrideAwStack): string;
+export declare function targetReleaseOverrideAwStackFromJSON(jsonString: string): SafeParseResult<TargetReleaseOverrideAwStack, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseOverrideAwBinding$inboundSchema: z.ZodType<TargetReleaseOverrideAwBinding, unknown>;
+/** @internal */
+export type TargetReleaseOverrideAwBinding$Outbound = {
+    resource?: TargetReleaseOverrideAwResource$Outbound | undefined;
+    stack?: TargetReleaseOverrideAwStack$Outbound | undefined;
+};
+/** @internal */
+export declare const TargetReleaseOverrideAwBinding$outboundSchema: z.ZodType<TargetReleaseOverrideAwBinding$Outbound, TargetReleaseOverrideAwBinding>;
+export declare function targetReleaseOverrideAwBindingToJSON(targetReleaseOverrideAwBinding: TargetReleaseOverrideAwBinding): string;
+export declare function targetReleaseOverrideAwBindingFromJSON(jsonString: string): SafeParseResult<TargetReleaseOverrideAwBinding, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseOverrideEffect$inboundSchema: z.ZodEnum<typeof TargetReleaseOverrideEffect>;
+/** @internal */
+export declare const TargetReleaseOverrideEffect$outboundSchema: z.ZodEnum<typeof TargetReleaseOverrideEffect>;
+/** @internal */
+export declare const TargetReleaseOverrideAwGrant$inboundSchema: z.ZodType<TargetReleaseOverrideAwGrant, unknown>;
+/** @internal */
+export type TargetReleaseOverrideAwGrant$Outbound = {
+    actions?: Array<string> | null | undefined;
+    dataActions?: Array<string> | null | undefined;
+    permissions?: Array<string> | null | undefined;
+    predefinedRoles?: Array<string> | null | undefined;
+    residualPermissions?: Array<string> | null | undefined;
+};
+/** @internal */
+export declare const TargetReleaseOverrideAwGrant$outboundSchema: z.ZodType<TargetReleaseOverrideAwGrant$Outbound, TargetReleaseOverrideAwGrant>;
+export declare function targetReleaseOverrideAwGrantToJSON(targetReleaseOverrideAwGrant: TargetReleaseOverrideAwGrant): string;
+export declare function targetReleaseOverrideAwGrantFromJSON(jsonString: string): SafeParseResult<TargetReleaseOverrideAwGrant, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseOverrideAw$inboundSchema: z.ZodType<TargetReleaseOverrideAw, unknown>;
+/** @internal */
+export type TargetReleaseOverrideAw$Outbound = {
+    binding: TargetReleaseOverrideAwBinding$Outbound;
+    description?: string | null | undefined;
+    effect?: string | undefined;
+    grant: TargetReleaseOverrideAwGrant$Outbound;
+    label?: string | null | undefined;
+};
+/** @internal */
+export declare const TargetReleaseOverrideAw$outboundSchema: z.ZodType<TargetReleaseOverrideAw$Outbound, TargetReleaseOverrideAw>;
+export declare function targetReleaseOverrideAwToJSON(targetReleaseOverrideAw: TargetReleaseOverrideAw): string;
+export declare function targetReleaseOverrideAwFromJSON(jsonString: string): SafeParseResult<TargetReleaseOverrideAw, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseOverrideAzureResource$inboundSchema: z.ZodType<TargetReleaseOverrideAzureResource, unknown>;
+/** @internal */
+export type TargetReleaseOverrideAzureResource$Outbound = {
+    scope: string;
+};
+/** @internal */
+export declare const TargetReleaseOverrideAzureResource$outboundSchema: z.ZodType<TargetReleaseOverrideAzureResource$Outbound, TargetReleaseOverrideAzureResource>;
+export declare function targetReleaseOverrideAzureResourceToJSON(targetReleaseOverrideAzureResource: TargetReleaseOverrideAzureResource): string;
+export declare function targetReleaseOverrideAzureResourceFromJSON(jsonString: string): SafeParseResult<TargetReleaseOverrideAzureResource, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseOverrideAzureStack$inboundSchema: z.ZodType<TargetReleaseOverrideAzureStack, unknown>;
+/** @internal */
+export type TargetReleaseOverrideAzureStack$Outbound = {
+    scope: string;
+};
+/** @internal */
+export declare const TargetReleaseOverrideAzureStack$outboundSchema: z.ZodType<TargetReleaseOverrideAzureStack$Outbound, TargetReleaseOverrideAzureStack>;
+export declare function targetReleaseOverrideAzureStackToJSON(targetReleaseOverrideAzureStack: TargetReleaseOverrideAzureStack): string;
+export declare function targetReleaseOverrideAzureStackFromJSON(jsonString: string): SafeParseResult<TargetReleaseOverrideAzureStack, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseOverrideAzureBinding$inboundSchema: z.ZodType<TargetReleaseOverrideAzureBinding, unknown>;
+/** @internal */
+export type TargetReleaseOverrideAzureBinding$Outbound = {
+    resource?: TargetReleaseOverrideAzureResource$Outbound | undefined;
+    stack?: TargetReleaseOverrideAzureStack$Outbound | undefined;
+};
+/** @internal */
+export declare const TargetReleaseOverrideAzureBinding$outboundSchema: z.ZodType<TargetReleaseOverrideAzureBinding$Outbound, TargetReleaseOverrideAzureBinding>;
+export declare function targetReleaseOverrideAzureBindingToJSON(targetReleaseOverrideAzureBinding: TargetReleaseOverrideAzureBinding): string;
+export declare function targetReleaseOverrideAzureBindingFromJSON(jsonString: string): SafeParseResult<TargetReleaseOverrideAzureBinding, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseOverrideAzureGrant$inboundSchema: z.ZodType<TargetReleaseOverrideAzureGrant, unknown>;
+/** @internal */
+export type TargetReleaseOverrideAzureGrant$Outbound = {
+    actions?: Array<string> | null | undefined;
+    dataActions?: Array<string> | null | undefined;
+    permissions?: Array<string> | null | undefined;
+    predefinedRoles?: Array<string> | null | undefined;
+    residualPermissions?: Array<string> | null | undefined;
+};
+/** @internal */
+export declare const TargetReleaseOverrideAzureGrant$outboundSchema: z.ZodType<TargetReleaseOverrideAzureGrant$Outbound, TargetReleaseOverrideAzureGrant>;
+export declare function targetReleaseOverrideAzureGrantToJSON(targetReleaseOverrideAzureGrant: TargetReleaseOverrideAzureGrant): string;
+export declare function targetReleaseOverrideAzureGrantFromJSON(jsonString: string): SafeParseResult<TargetReleaseOverrideAzureGrant, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseOverrideAzure$inboundSchema: z.ZodType<TargetReleaseOverrideAzure, unknown>;
+/** @internal */
+export type TargetReleaseOverrideAzure$Outbound = {
+    binding: TargetReleaseOverrideAzureBinding$Outbound;
+    description?: string | null | undefined;
+    grant: TargetReleaseOverrideAzureGrant$Outbound;
+    label?: string | null | undefined;
+};
+/** @internal */
+export declare const TargetReleaseOverrideAzure$outboundSchema: z.ZodType<TargetReleaseOverrideAzure$Outbound, TargetReleaseOverrideAzure>;
+export declare function targetReleaseOverrideAzureToJSON(targetReleaseOverrideAzure: TargetReleaseOverrideAzure): string;
+export declare function targetReleaseOverrideAzureFromJSON(jsonString: string): SafeParseResult<TargetReleaseOverrideAzure, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseOverrideConditionResource$inboundSchema: z.ZodType<TargetReleaseOverrideConditionResource, unknown>;
+/** @internal */
+export type TargetReleaseOverrideConditionResource$Outbound = {
+    expression: string;
+    title: string;
+};
+/** @internal */
+export declare const TargetReleaseOverrideConditionResource$outboundSchema: z.ZodType<TargetReleaseOverrideConditionResource$Outbound, TargetReleaseOverrideConditionResource>;
+export declare function targetReleaseOverrideConditionResourceToJSON(targetReleaseOverrideConditionResource: TargetReleaseOverrideConditionResource): string;
+export declare function targetReleaseOverrideConditionResourceFromJSON(jsonString: string): SafeParseResult<TargetReleaseOverrideConditionResource, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseOverrideResourceConditionUnion$inboundSchema: z.ZodType<TargetReleaseOverrideResourceConditionUnion, unknown>;
+/** @internal */
+export type TargetReleaseOverrideResourceConditionUnion$Outbound = TargetReleaseOverrideConditionResource$Outbound | string;
+/** @internal */
+export declare const TargetReleaseOverrideResourceConditionUnion$outboundSchema: z.ZodType<TargetReleaseOverrideResourceConditionUnion$Outbound, TargetReleaseOverrideResourceConditionUnion>;
+export declare function targetReleaseOverrideResourceConditionUnionToJSON(targetReleaseOverrideResourceConditionUnion: TargetReleaseOverrideResourceConditionUnion): string;
+export declare function targetReleaseOverrideResourceConditionUnionFromJSON(jsonString: string): SafeParseResult<TargetReleaseOverrideResourceConditionUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseOverrideGcpResource$inboundSchema: z.ZodType<TargetReleaseOverrideGcpResource, unknown>;
+/** @internal */
+export type TargetReleaseOverrideGcpResource$Outbound = {
+    condition?: TargetReleaseOverrideConditionResource$Outbound | string | null | undefined;
+    scope: string;
+};
+/** @internal */
+export declare const TargetReleaseOverrideGcpResource$outboundSchema: z.ZodType<TargetReleaseOverrideGcpResource$Outbound, TargetReleaseOverrideGcpResource>;
+export declare function targetReleaseOverrideGcpResourceToJSON(targetReleaseOverrideGcpResource: TargetReleaseOverrideGcpResource): string;
+export declare function targetReleaseOverrideGcpResourceFromJSON(jsonString: string): SafeParseResult<TargetReleaseOverrideGcpResource, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseOverrideCondition$inboundSchema: z.ZodType<TargetReleaseOverrideCondition, unknown>;
+/** @internal */
+export type TargetReleaseOverrideCondition$Outbound = {
+    expression: string;
+    title: string;
+};
+/** @internal */
+export declare const TargetReleaseOverrideCondition$outboundSchema: z.ZodType<TargetReleaseOverrideCondition$Outbound, TargetReleaseOverrideCondition>;
+export declare function targetReleaseOverrideConditionToJSON(targetReleaseOverrideCondition: TargetReleaseOverrideCondition): string;
+export declare function targetReleaseOverrideConditionFromJSON(jsonString: string): SafeParseResult<TargetReleaseOverrideCondition, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseOverrideConditionUnion$inboundSchema: z.ZodType<TargetReleaseOverrideConditionUnion, unknown>;
+/** @internal */
+export type TargetReleaseOverrideConditionUnion$Outbound = TargetReleaseOverrideCondition$Outbound | string;
+/** @internal */
+export declare const TargetReleaseOverrideConditionUnion$outboundSchema: z.ZodType<TargetReleaseOverrideConditionUnion$Outbound, TargetReleaseOverrideConditionUnion>;
+export declare function targetReleaseOverrideConditionUnionToJSON(targetReleaseOverrideConditionUnion: TargetReleaseOverrideConditionUnion): string;
+export declare function targetReleaseOverrideConditionUnionFromJSON(jsonString: string): SafeParseResult<TargetReleaseOverrideConditionUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseOverrideGcpStack$inboundSchema: z.ZodType<TargetReleaseOverrideGcpStack, unknown>;
+/** @internal */
+export type TargetReleaseOverrideGcpStack$Outbound = {
+    condition?: TargetReleaseOverrideCondition$Outbound | string | null | undefined;
+    scope: string;
+};
+/** @internal */
+export declare const TargetReleaseOverrideGcpStack$outboundSchema: z.ZodType<TargetReleaseOverrideGcpStack$Outbound, TargetReleaseOverrideGcpStack>;
+export declare function targetReleaseOverrideGcpStackToJSON(targetReleaseOverrideGcpStack: TargetReleaseOverrideGcpStack): string;
+export declare function targetReleaseOverrideGcpStackFromJSON(jsonString: string): SafeParseResult<TargetReleaseOverrideGcpStack, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseOverrideGcpBinding$inboundSchema: z.ZodType<TargetReleaseOverrideGcpBinding, unknown>;
+/** @internal */
+export type TargetReleaseOverrideGcpBinding$Outbound = {
+    resource?: TargetReleaseOverrideGcpResource$Outbound | undefined;
+    stack?: TargetReleaseOverrideGcpStack$Outbound | undefined;
+};
+/** @internal */
+export declare const TargetReleaseOverrideGcpBinding$outboundSchema: z.ZodType<TargetReleaseOverrideGcpBinding$Outbound, TargetReleaseOverrideGcpBinding>;
+export declare function targetReleaseOverrideGcpBindingToJSON(targetReleaseOverrideGcpBinding: TargetReleaseOverrideGcpBinding): string;
+export declare function targetReleaseOverrideGcpBindingFromJSON(jsonString: string): SafeParseResult<TargetReleaseOverrideGcpBinding, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseOverrideGcpGrant$inboundSchema: z.ZodType<TargetReleaseOverrideGcpGrant, unknown>;
+/** @internal */
+export type TargetReleaseOverrideGcpGrant$Outbound = {
+    actions?: Array<string> | null | undefined;
+    dataActions?: Array<string> | null | undefined;
+    permissions?: Array<string> | null | undefined;
+    predefinedRoles?: Array<string> | null | undefined;
+    residualPermissions?: Array<string> | null | undefined;
+};
+/** @internal */
+export declare const TargetReleaseOverrideGcpGrant$outboundSchema: z.ZodType<TargetReleaseOverrideGcpGrant$Outbound, TargetReleaseOverrideGcpGrant>;
+export declare function targetReleaseOverrideGcpGrantToJSON(targetReleaseOverrideGcpGrant: TargetReleaseOverrideGcpGrant): string;
+export declare function targetReleaseOverrideGcpGrantFromJSON(jsonString: string): SafeParseResult<TargetReleaseOverrideGcpGrant, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseOverrideGcp$inboundSchema: z.ZodType<TargetReleaseOverrideGcp, unknown>;
+/** @internal */
+export type TargetReleaseOverrideGcp$Outbound = {
+    binding: TargetReleaseOverrideGcpBinding$Outbound;
+    description?: string | null | undefined;
+    grant: TargetReleaseOverrideGcpGrant$Outbound;
+    label?: string | null | undefined;
+};
+/** @internal */
+export declare const TargetReleaseOverrideGcp$outboundSchema: z.ZodType<TargetReleaseOverrideGcp$Outbound, TargetReleaseOverrideGcp>;
+export declare function targetReleaseOverrideGcpToJSON(targetReleaseOverrideGcp: TargetReleaseOverrideGcp): string;
+export declare function targetReleaseOverrideGcpFromJSON(jsonString: string): SafeParseResult<TargetReleaseOverrideGcp, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseOverridePlatforms$inboundSchema: z.ZodType<TargetReleaseOverridePlatforms, unknown>;
+/** @internal */
+export type TargetReleaseOverridePlatforms$Outbound = {
+    aws?: Array<TargetReleaseOverrideAw$Outbound> | null | undefined;
+    azure?: Array<TargetReleaseOverrideAzure$Outbound> | null | undefined;
+    gcp?: Array<TargetReleaseOverrideGcp$Outbound> | null | undefined;
+};
+/** @internal */
+export declare const TargetReleaseOverridePlatforms$outboundSchema: z.ZodType<TargetReleaseOverridePlatforms$Outbound, TargetReleaseOverridePlatforms>;
+export declare function targetReleaseOverridePlatformsToJSON(targetReleaseOverridePlatforms: TargetReleaseOverridePlatforms): string;
+export declare function targetReleaseOverridePlatformsFromJSON(jsonString: string): SafeParseResult<TargetReleaseOverridePlatforms, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseOverride$inboundSchema: z.ZodType<TargetReleaseOverride, unknown>;
+/** @internal */
+export type TargetReleaseOverride$Outbound = {
+    description: string;
+    id: string;
+    platforms: TargetReleaseOverridePlatforms$Outbound;
+};
+/** @internal */
+export declare const TargetReleaseOverride$outboundSchema: z.ZodType<TargetReleaseOverride$Outbound, TargetReleaseOverride>;
+export declare function targetReleaseOverrideToJSON(targetReleaseOverride: TargetReleaseOverride): string;
+export declare function targetReleaseOverrideFromJSON(jsonString: string): SafeParseResult<TargetReleaseOverride, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseOverrideUnion$inboundSchema: z.ZodType<TargetReleaseOverrideUnion, unknown>;
+/** @internal */
+export type TargetReleaseOverrideUnion$Outbound = TargetReleaseOverride$Outbound | string;
+/** @internal */
+export declare const TargetReleaseOverrideUnion$outboundSchema: z.ZodType<TargetReleaseOverrideUnion$Outbound, TargetReleaseOverrideUnion>;
+export declare function targetReleaseOverrideUnionToJSON(targetReleaseOverrideUnion: TargetReleaseOverrideUnion): string;
+export declare function targetReleaseOverrideUnionFromJSON(jsonString: string): SafeParseResult<TargetReleaseOverrideUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseManagement2$inboundSchema: z.ZodType<TargetReleaseManagement2, unknown>;
+/** @internal */
+export type TargetReleaseManagement2$Outbound = {
+    override: {
+        [k: string]: Array<TargetReleaseOverride$Outbound | string>;
+    };
+};
+/** @internal */
+export declare const TargetReleaseManagement2$outboundSchema: z.ZodType<TargetReleaseManagement2$Outbound, TargetReleaseManagement2>;
+export declare function targetReleaseManagement2ToJSON(targetReleaseManagement2: TargetReleaseManagement2): string;
+export declare function targetReleaseManagement2FromJSON(jsonString: string): SafeParseResult<TargetReleaseManagement2, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseExtendAwResource$inboundSchema: z.ZodType<TargetReleaseExtendAwResource, unknown>;
+/** @internal */
+export type TargetReleaseExtendAwResource$Outbound = {
+    condition?: {
+        [k: string]: {
+            [k: string]: string;
+        };
+    } | null | undefined;
+    notResources?: Array<string> | undefined;
+    resources: Array<string>;
+};
+/** @internal */
+export declare const TargetReleaseExtendAwResource$outboundSchema: z.ZodType<TargetReleaseExtendAwResource$Outbound, TargetReleaseExtendAwResource>;
+export declare function targetReleaseExtendAwResourceToJSON(targetReleaseExtendAwResource: TargetReleaseExtendAwResource): string;
+export declare function targetReleaseExtendAwResourceFromJSON(jsonString: string): SafeParseResult<TargetReleaseExtendAwResource, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseExtendAwStack$inboundSchema: z.ZodType<TargetReleaseExtendAwStack, unknown>;
+/** @internal */
+export type TargetReleaseExtendAwStack$Outbound = {
+    condition?: {
+        [k: string]: {
+            [k: string]: string;
+        };
+    } | null | undefined;
+    notResources?: Array<string> | undefined;
+    resources: Array<string>;
+};
+/** @internal */
+export declare const TargetReleaseExtendAwStack$outboundSchema: z.ZodType<TargetReleaseExtendAwStack$Outbound, TargetReleaseExtendAwStack>;
+export declare function targetReleaseExtendAwStackToJSON(targetReleaseExtendAwStack: TargetReleaseExtendAwStack): string;
+export declare function targetReleaseExtendAwStackFromJSON(jsonString: string): SafeParseResult<TargetReleaseExtendAwStack, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseExtendAwBinding$inboundSchema: z.ZodType<TargetReleaseExtendAwBinding, unknown>;
+/** @internal */
+export type TargetReleaseExtendAwBinding$Outbound = {
+    resource?: TargetReleaseExtendAwResource$Outbound | undefined;
+    stack?: TargetReleaseExtendAwStack$Outbound | undefined;
+};
+/** @internal */
+export declare const TargetReleaseExtendAwBinding$outboundSchema: z.ZodType<TargetReleaseExtendAwBinding$Outbound, TargetReleaseExtendAwBinding>;
+export declare function targetReleaseExtendAwBindingToJSON(targetReleaseExtendAwBinding: TargetReleaseExtendAwBinding): string;
+export declare function targetReleaseExtendAwBindingFromJSON(jsonString: string): SafeParseResult<TargetReleaseExtendAwBinding, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseExtendEffect$inboundSchema: z.ZodEnum<typeof TargetReleaseExtendEffect>;
+/** @internal */
+export declare const TargetReleaseExtendEffect$outboundSchema: z.ZodEnum<typeof TargetReleaseExtendEffect>;
+/** @internal */
+export declare const TargetReleaseExtendAwGrant$inboundSchema: z.ZodType<TargetReleaseExtendAwGrant, unknown>;
+/** @internal */
+export type TargetReleaseExtendAwGrant$Outbound = {
+    actions?: Array<string> | null | undefined;
+    dataActions?: Array<string> | null | undefined;
+    permissions?: Array<string> | null | undefined;
+    predefinedRoles?: Array<string> | null | undefined;
+    residualPermissions?: Array<string> | null | undefined;
+};
+/** @internal */
+export declare const TargetReleaseExtendAwGrant$outboundSchema: z.ZodType<TargetReleaseExtendAwGrant$Outbound, TargetReleaseExtendAwGrant>;
+export declare function targetReleaseExtendAwGrantToJSON(targetReleaseExtendAwGrant: TargetReleaseExtendAwGrant): string;
+export declare function targetReleaseExtendAwGrantFromJSON(jsonString: string): SafeParseResult<TargetReleaseExtendAwGrant, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseExtendAw$inboundSchema: z.ZodType<TargetReleaseExtendAw, unknown>;
+/** @internal */
+export type TargetReleaseExtendAw$Outbound = {
+    binding: TargetReleaseExtendAwBinding$Outbound;
+    description?: string | null | undefined;
+    effect?: string | undefined;
+    grant: TargetReleaseExtendAwGrant$Outbound;
+    label?: string | null | undefined;
+};
+/** @internal */
+export declare const TargetReleaseExtendAw$outboundSchema: z.ZodType<TargetReleaseExtendAw$Outbound, TargetReleaseExtendAw>;
+export declare function targetReleaseExtendAwToJSON(targetReleaseExtendAw: TargetReleaseExtendAw): string;
+export declare function targetReleaseExtendAwFromJSON(jsonString: string): SafeParseResult<TargetReleaseExtendAw, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseExtendAzureResource$inboundSchema: z.ZodType<TargetReleaseExtendAzureResource, unknown>;
+/** @internal */
+export type TargetReleaseExtendAzureResource$Outbound = {
+    scope: string;
+};
+/** @internal */
+export declare const TargetReleaseExtendAzureResource$outboundSchema: z.ZodType<TargetReleaseExtendAzureResource$Outbound, TargetReleaseExtendAzureResource>;
+export declare function targetReleaseExtendAzureResourceToJSON(targetReleaseExtendAzureResource: TargetReleaseExtendAzureResource): string;
+export declare function targetReleaseExtendAzureResourceFromJSON(jsonString: string): SafeParseResult<TargetReleaseExtendAzureResource, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseExtendAzureStack$inboundSchema: z.ZodType<TargetReleaseExtendAzureStack, unknown>;
+/** @internal */
+export type TargetReleaseExtendAzureStack$Outbound = {
+    scope: string;
+};
+/** @internal */
+export declare const TargetReleaseExtendAzureStack$outboundSchema: z.ZodType<TargetReleaseExtendAzureStack$Outbound, TargetReleaseExtendAzureStack>;
+export declare function targetReleaseExtendAzureStackToJSON(targetReleaseExtendAzureStack: TargetReleaseExtendAzureStack): string;
+export declare function targetReleaseExtendAzureStackFromJSON(jsonString: string): SafeParseResult<TargetReleaseExtendAzureStack, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseExtendAzureBinding$inboundSchema: z.ZodType<TargetReleaseExtendAzureBinding, unknown>;
+/** @internal */
+export type TargetReleaseExtendAzureBinding$Outbound = {
+    resource?: TargetReleaseExtendAzureResource$Outbound | undefined;
+    stack?: TargetReleaseExtendAzureStack$Outbound | undefined;
+};
+/** @internal */
+export declare const TargetReleaseExtendAzureBinding$outboundSchema: z.ZodType<TargetReleaseExtendAzureBinding$Outbound, TargetReleaseExtendAzureBinding>;
+export declare function targetReleaseExtendAzureBindingToJSON(targetReleaseExtendAzureBinding: TargetReleaseExtendAzureBinding): string;
+export declare function targetReleaseExtendAzureBindingFromJSON(jsonString: string): SafeParseResult<TargetReleaseExtendAzureBinding, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseExtendAzureGrant$inboundSchema: z.ZodType<TargetReleaseExtendAzureGrant, unknown>;
+/** @internal */
+export type TargetReleaseExtendAzureGrant$Outbound = {
+    actions?: Array<string> | null | undefined;
+    dataActions?: Array<string> | null | undefined;
+    permissions?: Array<string> | null | undefined;
+    predefinedRoles?: Array<string> | null | undefined;
+    residualPermissions?: Array<string> | null | undefined;
+};
+/** @internal */
+export declare const TargetReleaseExtendAzureGrant$outboundSchema: z.ZodType<TargetReleaseExtendAzureGrant$Outbound, TargetReleaseExtendAzureGrant>;
+export declare function targetReleaseExtendAzureGrantToJSON(targetReleaseExtendAzureGrant: TargetReleaseExtendAzureGrant): string;
+export declare function targetReleaseExtendAzureGrantFromJSON(jsonString: string): SafeParseResult<TargetReleaseExtendAzureGrant, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseExtendAzure$inboundSchema: z.ZodType<TargetReleaseExtendAzure, unknown>;
+/** @internal */
+export type TargetReleaseExtendAzure$Outbound = {
+    binding: TargetReleaseExtendAzureBinding$Outbound;
+    description?: string | null | undefined;
+    grant: TargetReleaseExtendAzureGrant$Outbound;
+    label?: string | null | undefined;
+};
+/** @internal */
+export declare const TargetReleaseExtendAzure$outboundSchema: z.ZodType<TargetReleaseExtendAzure$Outbound, TargetReleaseExtendAzure>;
+export declare function targetReleaseExtendAzureToJSON(targetReleaseExtendAzure: TargetReleaseExtendAzure): string;
+export declare function targetReleaseExtendAzureFromJSON(jsonString: string): SafeParseResult<TargetReleaseExtendAzure, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseExtendConditionResource$inboundSchema: z.ZodType<TargetReleaseExtendConditionResource, unknown>;
+/** @internal */
+export type TargetReleaseExtendConditionResource$Outbound = {
+    expression: string;
+    title: string;
+};
+/** @internal */
+export declare const TargetReleaseExtendConditionResource$outboundSchema: z.ZodType<TargetReleaseExtendConditionResource$Outbound, TargetReleaseExtendConditionResource>;
+export declare function targetReleaseExtendConditionResourceToJSON(targetReleaseExtendConditionResource: TargetReleaseExtendConditionResource): string;
+export declare function targetReleaseExtendConditionResourceFromJSON(jsonString: string): SafeParseResult<TargetReleaseExtendConditionResource, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseExtendResourceConditionUnion$inboundSchema: z.ZodType<TargetReleaseExtendResourceConditionUnion, unknown>;
+/** @internal */
+export type TargetReleaseExtendResourceConditionUnion$Outbound = TargetReleaseExtendConditionResource$Outbound | string;
+/** @internal */
+export declare const TargetReleaseExtendResourceConditionUnion$outboundSchema: z.ZodType<TargetReleaseExtendResourceConditionUnion$Outbound, TargetReleaseExtendResourceConditionUnion>;
+export declare function targetReleaseExtendResourceConditionUnionToJSON(targetReleaseExtendResourceConditionUnion: TargetReleaseExtendResourceConditionUnion): string;
+export declare function targetReleaseExtendResourceConditionUnionFromJSON(jsonString: string): SafeParseResult<TargetReleaseExtendResourceConditionUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseExtendGcpResource$inboundSchema: z.ZodType<TargetReleaseExtendGcpResource, unknown>;
+/** @internal */
+export type TargetReleaseExtendGcpResource$Outbound = {
+    condition?: TargetReleaseExtendConditionResource$Outbound | string | null | undefined;
+    scope: string;
+};
+/** @internal */
+export declare const TargetReleaseExtendGcpResource$outboundSchema: z.ZodType<TargetReleaseExtendGcpResource$Outbound, TargetReleaseExtendGcpResource>;
+export declare function targetReleaseExtendGcpResourceToJSON(targetReleaseExtendGcpResource: TargetReleaseExtendGcpResource): string;
+export declare function targetReleaseExtendGcpResourceFromJSON(jsonString: string): SafeParseResult<TargetReleaseExtendGcpResource, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseExtendCondition$inboundSchema: z.ZodType<TargetReleaseExtendCondition, unknown>;
+/** @internal */
+export type TargetReleaseExtendCondition$Outbound = {
+    expression: string;
+    title: string;
+};
+/** @internal */
+export declare const TargetReleaseExtendCondition$outboundSchema: z.ZodType<TargetReleaseExtendCondition$Outbound, TargetReleaseExtendCondition>;
+export declare function targetReleaseExtendConditionToJSON(targetReleaseExtendCondition: TargetReleaseExtendCondition): string;
+export declare function targetReleaseExtendConditionFromJSON(jsonString: string): SafeParseResult<TargetReleaseExtendCondition, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseExtendConditionUnion$inboundSchema: z.ZodType<TargetReleaseExtendConditionUnion, unknown>;
+/** @internal */
+export type TargetReleaseExtendConditionUnion$Outbound = TargetReleaseExtendCondition$Outbound | string;
+/** @internal */
+export declare const TargetReleaseExtendConditionUnion$outboundSchema: z.ZodType<TargetReleaseExtendConditionUnion$Outbound, TargetReleaseExtendConditionUnion>;
+export declare function targetReleaseExtendConditionUnionToJSON(targetReleaseExtendConditionUnion: TargetReleaseExtendConditionUnion): string;
+export declare function targetReleaseExtendConditionUnionFromJSON(jsonString: string): SafeParseResult<TargetReleaseExtendConditionUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseExtendGcpStack$inboundSchema: z.ZodType<TargetReleaseExtendGcpStack, unknown>;
+/** @internal */
+export type TargetReleaseExtendGcpStack$Outbound = {
+    condition?: TargetReleaseExtendCondition$Outbound | string | null | undefined;
+    scope: string;
+};
+/** @internal */
+export declare const TargetReleaseExtendGcpStack$outboundSchema: z.ZodType<TargetReleaseExtendGcpStack$Outbound, TargetReleaseExtendGcpStack>;
+export declare function targetReleaseExtendGcpStackToJSON(targetReleaseExtendGcpStack: TargetReleaseExtendGcpStack): string;
+export declare function targetReleaseExtendGcpStackFromJSON(jsonString: string): SafeParseResult<TargetReleaseExtendGcpStack, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseExtendGcpBinding$inboundSchema: z.ZodType<TargetReleaseExtendGcpBinding, unknown>;
+/** @internal */
+export type TargetReleaseExtendGcpBinding$Outbound = {
+    resource?: TargetReleaseExtendGcpResource$Outbound | undefined;
+    stack?: TargetReleaseExtendGcpStack$Outbound | undefined;
+};
+/** @internal */
+export declare const TargetReleaseExtendGcpBinding$outboundSchema: z.ZodType<TargetReleaseExtendGcpBinding$Outbound, TargetReleaseExtendGcpBinding>;
+export declare function targetReleaseExtendGcpBindingToJSON(targetReleaseExtendGcpBinding: TargetReleaseExtendGcpBinding): string;
+export declare function targetReleaseExtendGcpBindingFromJSON(jsonString: string): SafeParseResult<TargetReleaseExtendGcpBinding, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseExtendGcpGrant$inboundSchema: z.ZodType<TargetReleaseExtendGcpGrant, unknown>;
+/** @internal */
+export type TargetReleaseExtendGcpGrant$Outbound = {
+    actions?: Array<string> | null | undefined;
+    dataActions?: Array<string> | null | undefined;
+    permissions?: Array<string> | null | undefined;
+    predefinedRoles?: Array<string> | null | undefined;
+    residualPermissions?: Array<string> | null | undefined;
+};
+/** @internal */
+export declare const TargetReleaseExtendGcpGrant$outboundSchema: z.ZodType<TargetReleaseExtendGcpGrant$Outbound, TargetReleaseExtendGcpGrant>;
+export declare function targetReleaseExtendGcpGrantToJSON(targetReleaseExtendGcpGrant: TargetReleaseExtendGcpGrant): string;
+export declare function targetReleaseExtendGcpGrantFromJSON(jsonString: string): SafeParseResult<TargetReleaseExtendGcpGrant, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseExtendGcp$inboundSchema: z.ZodType<TargetReleaseExtendGcp, unknown>;
+/** @internal */
+export type TargetReleaseExtendGcp$Outbound = {
+    binding: TargetReleaseExtendGcpBinding$Outbound;
+    description?: string | null | undefined;
+    grant: TargetReleaseExtendGcpGrant$Outbound;
+    label?: string | null | undefined;
+};
+/** @internal */
+export declare const TargetReleaseExtendGcp$outboundSchema: z.ZodType<TargetReleaseExtendGcp$Outbound, TargetReleaseExtendGcp>;
+export declare function targetReleaseExtendGcpToJSON(targetReleaseExtendGcp: TargetReleaseExtendGcp): string;
+export declare function targetReleaseExtendGcpFromJSON(jsonString: string): SafeParseResult<TargetReleaseExtendGcp, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseExtendPlatforms$inboundSchema: z.ZodType<TargetReleaseExtendPlatforms, unknown>;
+/** @internal */
+export type TargetReleaseExtendPlatforms$Outbound = {
+    aws?: Array<TargetReleaseExtendAw$Outbound> | null | undefined;
+    azure?: Array<TargetReleaseExtendAzure$Outbound> | null | undefined;
+    gcp?: Array<TargetReleaseExtendGcp$Outbound> | null | undefined;
+};
+/** @internal */
+export declare const TargetReleaseExtendPlatforms$outboundSchema: z.ZodType<TargetReleaseExtendPlatforms$Outbound, TargetReleaseExtendPlatforms>;
+export declare function targetReleaseExtendPlatformsToJSON(targetReleaseExtendPlatforms: TargetReleaseExtendPlatforms): string;
+export declare function targetReleaseExtendPlatformsFromJSON(jsonString: string): SafeParseResult<TargetReleaseExtendPlatforms, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseExtend$inboundSchema: z.ZodType<TargetReleaseExtend, unknown>;
+/** @internal */
+export type TargetReleaseExtend$Outbound = {
+    description: string;
+    id: string;
+    platforms: TargetReleaseExtendPlatforms$Outbound;
+};
+/** @internal */
+export declare const TargetReleaseExtend$outboundSchema: z.ZodType<TargetReleaseExtend$Outbound, TargetReleaseExtend>;
+export declare function targetReleaseExtendToJSON(targetReleaseExtend: TargetReleaseExtend): string;
+export declare function targetReleaseExtendFromJSON(jsonString: string): SafeParseResult<TargetReleaseExtend, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseExtendUnion$inboundSchema: z.ZodType<TargetReleaseExtendUnion, unknown>;
+/** @internal */
+export type TargetReleaseExtendUnion$Outbound = TargetReleaseExtend$Outbound | string;
+/** @internal */
+export declare const TargetReleaseExtendUnion$outboundSchema: z.ZodType<TargetReleaseExtendUnion$Outbound, TargetReleaseExtendUnion>;
+export declare function targetReleaseExtendUnionToJSON(targetReleaseExtendUnion: TargetReleaseExtendUnion): string;
+export declare function targetReleaseExtendUnionFromJSON(jsonString: string): SafeParseResult<TargetReleaseExtendUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseManagement1$inboundSchema: z.ZodType<TargetReleaseManagement1, unknown>;
+/** @internal */
+export type TargetReleaseManagement1$Outbound = {
+    extend: {
+        [k: string]: Array<TargetReleaseExtend$Outbound | string>;
+    };
+};
+/** @internal */
+export declare const TargetReleaseManagement1$outboundSchema: z.ZodType<TargetReleaseManagement1$Outbound, TargetReleaseManagement1>;
+export declare function targetReleaseManagement1ToJSON(targetReleaseManagement1: TargetReleaseManagement1): string;
+export declare function targetReleaseManagement1FromJSON(jsonString: string): SafeParseResult<TargetReleaseManagement1, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseManagementUnion$inboundSchema: z.ZodType<TargetReleaseManagementUnion, unknown>;
+/** @internal */
+export type TargetReleaseManagementUnion$Outbound = TargetReleaseManagement1$Outbound | TargetReleaseManagement2$Outbound | string;
+/** @internal */
+export declare const TargetReleaseManagementUnion$outboundSchema: z.ZodType<TargetReleaseManagementUnion$Outbound, TargetReleaseManagementUnion>;
+export declare function targetReleaseManagementUnionToJSON(targetReleaseManagementUnion: TargetReleaseManagementUnion): string;
+export declare function targetReleaseManagementUnionFromJSON(jsonString: string): SafeParseResult<TargetReleaseManagementUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseProfileAwResource$inboundSchema: z.ZodType<TargetReleaseProfileAwResource, unknown>;
+/** @internal */
+export type TargetReleaseProfileAwResource$Outbound = {
+    condition?: {
+        [k: string]: {
+            [k: string]: string;
+        };
+    } | null | undefined;
+    notResources?: Array<string> | undefined;
+    resources: Array<string>;
+};
+/** @internal */
+export declare const TargetReleaseProfileAwResource$outboundSchema: z.ZodType<TargetReleaseProfileAwResource$Outbound, TargetReleaseProfileAwResource>;
+export declare function targetReleaseProfileAwResourceToJSON(targetReleaseProfileAwResource: TargetReleaseProfileAwResource): string;
+export declare function targetReleaseProfileAwResourceFromJSON(jsonString: string): SafeParseResult<TargetReleaseProfileAwResource, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseProfileAwStack$inboundSchema: z.ZodType<TargetReleaseProfileAwStack, unknown>;
+/** @internal */
+export type TargetReleaseProfileAwStack$Outbound = {
+    condition?: {
+        [k: string]: {
+            [k: string]: string;
+        };
+    } | null | undefined;
+    notResources?: Array<string> | undefined;
+    resources: Array<string>;
+};
+/** @internal */
+export declare const TargetReleaseProfileAwStack$outboundSchema: z.ZodType<TargetReleaseProfileAwStack$Outbound, TargetReleaseProfileAwStack>;
+export declare function targetReleaseProfileAwStackToJSON(targetReleaseProfileAwStack: TargetReleaseProfileAwStack): string;
+export declare function targetReleaseProfileAwStackFromJSON(jsonString: string): SafeParseResult<TargetReleaseProfileAwStack, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseProfileAwBinding$inboundSchema: z.ZodType<TargetReleaseProfileAwBinding, unknown>;
+/** @internal */
+export type TargetReleaseProfileAwBinding$Outbound = {
+    resource?: TargetReleaseProfileAwResource$Outbound | undefined;
+    stack?: TargetReleaseProfileAwStack$Outbound | undefined;
+};
+/** @internal */
+export declare const TargetReleaseProfileAwBinding$outboundSchema: z.ZodType<TargetReleaseProfileAwBinding$Outbound, TargetReleaseProfileAwBinding>;
+export declare function targetReleaseProfileAwBindingToJSON(targetReleaseProfileAwBinding: TargetReleaseProfileAwBinding): string;
+export declare function targetReleaseProfileAwBindingFromJSON(jsonString: string): SafeParseResult<TargetReleaseProfileAwBinding, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseProfileEffect$inboundSchema: z.ZodEnum<typeof TargetReleaseProfileEffect>;
+/** @internal */
+export declare const TargetReleaseProfileEffect$outboundSchema: z.ZodEnum<typeof TargetReleaseProfileEffect>;
+/** @internal */
+export declare const TargetReleaseProfileAwGrant$inboundSchema: z.ZodType<TargetReleaseProfileAwGrant, unknown>;
+/** @internal */
+export type TargetReleaseProfileAwGrant$Outbound = {
+    actions?: Array<string> | null | undefined;
+    dataActions?: Array<string> | null | undefined;
+    permissions?: Array<string> | null | undefined;
+    predefinedRoles?: Array<string> | null | undefined;
+    residualPermissions?: Array<string> | null | undefined;
+};
+/** @internal */
+export declare const TargetReleaseProfileAwGrant$outboundSchema: z.ZodType<TargetReleaseProfileAwGrant$Outbound, TargetReleaseProfileAwGrant>;
+export declare function targetReleaseProfileAwGrantToJSON(targetReleaseProfileAwGrant: TargetReleaseProfileAwGrant): string;
+export declare function targetReleaseProfileAwGrantFromJSON(jsonString: string): SafeParseResult<TargetReleaseProfileAwGrant, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseProfileAw$inboundSchema: z.ZodType<TargetReleaseProfileAw, unknown>;
+/** @internal */
+export type TargetReleaseProfileAw$Outbound = {
+    binding: TargetReleaseProfileAwBinding$Outbound;
+    description?: string | null | undefined;
+    effect?: string | undefined;
+    grant: TargetReleaseProfileAwGrant$Outbound;
+    label?: string | null | undefined;
+};
+/** @internal */
+export declare const TargetReleaseProfileAw$outboundSchema: z.ZodType<TargetReleaseProfileAw$Outbound, TargetReleaseProfileAw>;
+export declare function targetReleaseProfileAwToJSON(targetReleaseProfileAw: TargetReleaseProfileAw): string;
+export declare function targetReleaseProfileAwFromJSON(jsonString: string): SafeParseResult<TargetReleaseProfileAw, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseProfileAzureResource$inboundSchema: z.ZodType<TargetReleaseProfileAzureResource, unknown>;
+/** @internal */
+export type TargetReleaseProfileAzureResource$Outbound = {
+    scope: string;
+};
+/** @internal */
+export declare const TargetReleaseProfileAzureResource$outboundSchema: z.ZodType<TargetReleaseProfileAzureResource$Outbound, TargetReleaseProfileAzureResource>;
+export declare function targetReleaseProfileAzureResourceToJSON(targetReleaseProfileAzureResource: TargetReleaseProfileAzureResource): string;
+export declare function targetReleaseProfileAzureResourceFromJSON(jsonString: string): SafeParseResult<TargetReleaseProfileAzureResource, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseProfileAzureStack$inboundSchema: z.ZodType<TargetReleaseProfileAzureStack, unknown>;
+/** @internal */
+export type TargetReleaseProfileAzureStack$Outbound = {
+    scope: string;
+};
+/** @internal */
+export declare const TargetReleaseProfileAzureStack$outboundSchema: z.ZodType<TargetReleaseProfileAzureStack$Outbound, TargetReleaseProfileAzureStack>;
+export declare function targetReleaseProfileAzureStackToJSON(targetReleaseProfileAzureStack: TargetReleaseProfileAzureStack): string;
+export declare function targetReleaseProfileAzureStackFromJSON(jsonString: string): SafeParseResult<TargetReleaseProfileAzureStack, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseProfileAzureBinding$inboundSchema: z.ZodType<TargetReleaseProfileAzureBinding, unknown>;
+/** @internal */
+export type TargetReleaseProfileAzureBinding$Outbound = {
+    resource?: TargetReleaseProfileAzureResource$Outbound | undefined;
+    stack?: TargetReleaseProfileAzureStack$Outbound | undefined;
+};
+/** @internal */
+export declare const TargetReleaseProfileAzureBinding$outboundSchema: z.ZodType<TargetReleaseProfileAzureBinding$Outbound, TargetReleaseProfileAzureBinding>;
+export declare function targetReleaseProfileAzureBindingToJSON(targetReleaseProfileAzureBinding: TargetReleaseProfileAzureBinding): string;
+export declare function targetReleaseProfileAzureBindingFromJSON(jsonString: string): SafeParseResult<TargetReleaseProfileAzureBinding, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseProfileAzureGrant$inboundSchema: z.ZodType<TargetReleaseProfileAzureGrant, unknown>;
+/** @internal */
+export type TargetReleaseProfileAzureGrant$Outbound = {
+    actions?: Array<string> | null | undefined;
+    dataActions?: Array<string> | null | undefined;
+    permissions?: Array<string> | null | undefined;
+    predefinedRoles?: Array<string> | null | undefined;
+    residualPermissions?: Array<string> | null | undefined;
+};
+/** @internal */
+export declare const TargetReleaseProfileAzureGrant$outboundSchema: z.ZodType<TargetReleaseProfileAzureGrant$Outbound, TargetReleaseProfileAzureGrant>;
+export declare function targetReleaseProfileAzureGrantToJSON(targetReleaseProfileAzureGrant: TargetReleaseProfileAzureGrant): string;
+export declare function targetReleaseProfileAzureGrantFromJSON(jsonString: string): SafeParseResult<TargetReleaseProfileAzureGrant, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseProfileAzure$inboundSchema: z.ZodType<TargetReleaseProfileAzure, unknown>;
+/** @internal */
+export type TargetReleaseProfileAzure$Outbound = {
+    binding: TargetReleaseProfileAzureBinding$Outbound;
+    description?: string | null | undefined;
+    grant: TargetReleaseProfileAzureGrant$Outbound;
+    label?: string | null | undefined;
+};
+/** @internal */
+export declare const TargetReleaseProfileAzure$outboundSchema: z.ZodType<TargetReleaseProfileAzure$Outbound, TargetReleaseProfileAzure>;
+export declare function targetReleaseProfileAzureToJSON(targetReleaseProfileAzure: TargetReleaseProfileAzure): string;
+export declare function targetReleaseProfileAzureFromJSON(jsonString: string): SafeParseResult<TargetReleaseProfileAzure, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseProfileConditionResource$inboundSchema: z.ZodType<TargetReleaseProfileConditionResource, unknown>;
+/** @internal */
+export type TargetReleaseProfileConditionResource$Outbound = {
+    expression: string;
+    title: string;
+};
+/** @internal */
+export declare const TargetReleaseProfileConditionResource$outboundSchema: z.ZodType<TargetReleaseProfileConditionResource$Outbound, TargetReleaseProfileConditionResource>;
+export declare function targetReleaseProfileConditionResourceToJSON(targetReleaseProfileConditionResource: TargetReleaseProfileConditionResource): string;
+export declare function targetReleaseProfileConditionResourceFromJSON(jsonString: string): SafeParseResult<TargetReleaseProfileConditionResource, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseProfileResourceConditionUnion$inboundSchema: z.ZodType<TargetReleaseProfileResourceConditionUnion, unknown>;
+/** @internal */
+export type TargetReleaseProfileResourceConditionUnion$Outbound = TargetReleaseProfileConditionResource$Outbound | string;
+/** @internal */
+export declare const TargetReleaseProfileResourceConditionUnion$outboundSchema: z.ZodType<TargetReleaseProfileResourceConditionUnion$Outbound, TargetReleaseProfileResourceConditionUnion>;
+export declare function targetReleaseProfileResourceConditionUnionToJSON(targetReleaseProfileResourceConditionUnion: TargetReleaseProfileResourceConditionUnion): string;
+export declare function targetReleaseProfileResourceConditionUnionFromJSON(jsonString: string): SafeParseResult<TargetReleaseProfileResourceConditionUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseProfileGcpResource$inboundSchema: z.ZodType<TargetReleaseProfileGcpResource, unknown>;
+/** @internal */
+export type TargetReleaseProfileGcpResource$Outbound = {
+    condition?: TargetReleaseProfileConditionResource$Outbound | string | null | undefined;
+    scope: string;
+};
+/** @internal */
+export declare const TargetReleaseProfileGcpResource$outboundSchema: z.ZodType<TargetReleaseProfileGcpResource$Outbound, TargetReleaseProfileGcpResource>;
+export declare function targetReleaseProfileGcpResourceToJSON(targetReleaseProfileGcpResource: TargetReleaseProfileGcpResource): string;
+export declare function targetReleaseProfileGcpResourceFromJSON(jsonString: string): SafeParseResult<TargetReleaseProfileGcpResource, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseProfileCondition$inboundSchema: z.ZodType<TargetReleaseProfileCondition, unknown>;
+/** @internal */
+export type TargetReleaseProfileCondition$Outbound = {
+    expression: string;
+    title: string;
+};
+/** @internal */
+export declare const TargetReleaseProfileCondition$outboundSchema: z.ZodType<TargetReleaseProfileCondition$Outbound, TargetReleaseProfileCondition>;
+export declare function targetReleaseProfileConditionToJSON(targetReleaseProfileCondition: TargetReleaseProfileCondition): string;
+export declare function targetReleaseProfileConditionFromJSON(jsonString: string): SafeParseResult<TargetReleaseProfileCondition, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseProfileConditionUnion$inboundSchema: z.ZodType<TargetReleaseProfileConditionUnion, unknown>;
+/** @internal */
+export type TargetReleaseProfileConditionUnion$Outbound = TargetReleaseProfileCondition$Outbound | string;
+/** @internal */
+export declare const TargetReleaseProfileConditionUnion$outboundSchema: z.ZodType<TargetReleaseProfileConditionUnion$Outbound, TargetReleaseProfileConditionUnion>;
+export declare function targetReleaseProfileConditionUnionToJSON(targetReleaseProfileConditionUnion: TargetReleaseProfileConditionUnion): string;
+export declare function targetReleaseProfileConditionUnionFromJSON(jsonString: string): SafeParseResult<TargetReleaseProfileConditionUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseProfileGcpStack$inboundSchema: z.ZodType<TargetReleaseProfileGcpStack, unknown>;
+/** @internal */
+export type TargetReleaseProfileGcpStack$Outbound = {
+    condition?: TargetReleaseProfileCondition$Outbound | string | null | undefined;
+    scope: string;
+};
+/** @internal */
+export declare const TargetReleaseProfileGcpStack$outboundSchema: z.ZodType<TargetReleaseProfileGcpStack$Outbound, TargetReleaseProfileGcpStack>;
+export declare function targetReleaseProfileGcpStackToJSON(targetReleaseProfileGcpStack: TargetReleaseProfileGcpStack): string;
+export declare function targetReleaseProfileGcpStackFromJSON(jsonString: string): SafeParseResult<TargetReleaseProfileGcpStack, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseProfileGcpBinding$inboundSchema: z.ZodType<TargetReleaseProfileGcpBinding, unknown>;
+/** @internal */
+export type TargetReleaseProfileGcpBinding$Outbound = {
+    resource?: TargetReleaseProfileGcpResource$Outbound | undefined;
+    stack?: TargetReleaseProfileGcpStack$Outbound | undefined;
+};
+/** @internal */
+export declare const TargetReleaseProfileGcpBinding$outboundSchema: z.ZodType<TargetReleaseProfileGcpBinding$Outbound, TargetReleaseProfileGcpBinding>;
+export declare function targetReleaseProfileGcpBindingToJSON(targetReleaseProfileGcpBinding: TargetReleaseProfileGcpBinding): string;
+export declare function targetReleaseProfileGcpBindingFromJSON(jsonString: string): SafeParseResult<TargetReleaseProfileGcpBinding, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseProfileGcpGrant$inboundSchema: z.ZodType<TargetReleaseProfileGcpGrant, unknown>;
+/** @internal */
+export type TargetReleaseProfileGcpGrant$Outbound = {
+    actions?: Array<string> | null | undefined;
+    dataActions?: Array<string> | null | undefined;
+    permissions?: Array<string> | null | undefined;
+    predefinedRoles?: Array<string> | null | undefined;
+    residualPermissions?: Array<string> | null | undefined;
+};
+/** @internal */
+export declare const TargetReleaseProfileGcpGrant$outboundSchema: z.ZodType<TargetReleaseProfileGcpGrant$Outbound, TargetReleaseProfileGcpGrant>;
+export declare function targetReleaseProfileGcpGrantToJSON(targetReleaseProfileGcpGrant: TargetReleaseProfileGcpGrant): string;
+export declare function targetReleaseProfileGcpGrantFromJSON(jsonString: string): SafeParseResult<TargetReleaseProfileGcpGrant, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseProfileGcp$inboundSchema: z.ZodType<TargetReleaseProfileGcp, unknown>;
+/** @internal */
+export type TargetReleaseProfileGcp$Outbound = {
+    binding: TargetReleaseProfileGcpBinding$Outbound;
+    description?: string | null | undefined;
+    grant: TargetReleaseProfileGcpGrant$Outbound;
+    label?: string | null | undefined;
+};
+/** @internal */
+export declare const TargetReleaseProfileGcp$outboundSchema: z.ZodType<TargetReleaseProfileGcp$Outbound, TargetReleaseProfileGcp>;
+export declare function targetReleaseProfileGcpToJSON(targetReleaseProfileGcp: TargetReleaseProfileGcp): string;
+export declare function targetReleaseProfileGcpFromJSON(jsonString: string): SafeParseResult<TargetReleaseProfileGcp, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseProfilePlatforms$inboundSchema: z.ZodType<TargetReleaseProfilePlatforms, unknown>;
+/** @internal */
+export type TargetReleaseProfilePlatforms$Outbound = {
+    aws?: Array<TargetReleaseProfileAw$Outbound> | null | undefined;
+    azure?: Array<TargetReleaseProfileAzure$Outbound> | null | undefined;
+    gcp?: Array<TargetReleaseProfileGcp$Outbound> | null | undefined;
+};
+/** @internal */
+export declare const TargetReleaseProfilePlatforms$outboundSchema: z.ZodType<TargetReleaseProfilePlatforms$Outbound, TargetReleaseProfilePlatforms>;
+export declare function targetReleaseProfilePlatformsToJSON(targetReleaseProfilePlatforms: TargetReleaseProfilePlatforms): string;
+export declare function targetReleaseProfilePlatformsFromJSON(jsonString: string): SafeParseResult<TargetReleaseProfilePlatforms, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseProfile$inboundSchema: z.ZodType<TargetReleaseProfile, unknown>;
+/** @internal */
+export type TargetReleaseProfile$Outbound = {
+    description: string;
+    id: string;
+    platforms: TargetReleaseProfilePlatforms$Outbound;
+};
+/** @internal */
+export declare const TargetReleaseProfile$outboundSchema: z.ZodType<TargetReleaseProfile$Outbound, TargetReleaseProfile>;
+export declare function targetReleaseProfileToJSON(targetReleaseProfile: TargetReleaseProfile): string;
+export declare function targetReleaseProfileFromJSON(jsonString: string): SafeParseResult<TargetReleaseProfile, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseProfileUnion$inboundSchema: z.ZodType<TargetReleaseProfileUnion, unknown>;
+/** @internal */
+export type TargetReleaseProfileUnion$Outbound = TargetReleaseProfile$Outbound | string;
+/** @internal */
+export declare const TargetReleaseProfileUnion$outboundSchema: z.ZodType<TargetReleaseProfileUnion$Outbound, TargetReleaseProfileUnion>;
+export declare function targetReleaseProfileUnionToJSON(targetReleaseProfileUnion: TargetReleaseProfileUnion): string;
+export declare function targetReleaseProfileUnionFromJSON(jsonString: string): SafeParseResult<TargetReleaseProfileUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetReleasePermissions$inboundSchema: z.ZodType<TargetReleasePermissions, unknown>;
+/** @internal */
+export type TargetReleasePermissions$Outbound = {
+    management?: TargetReleaseManagement1$Outbound | TargetReleaseManagement2$Outbound | string | undefined;
+    profiles: {
+        [k: string]: {
+            [k: string]: Array<TargetReleaseProfile$Outbound | string>;
+        };
+    };
+};
+/** @internal */
+export declare const TargetReleasePermissions$outboundSchema: z.ZodType<TargetReleasePermissions$Outbound, TargetReleasePermissions>;
+export declare function targetReleasePermissionsToJSON(targetReleasePermissions: TargetReleasePermissions): string;
+export declare function targetReleasePermissionsFromJSON(jsonString: string): SafeParseResult<TargetReleasePermissions, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseConfig$inboundSchema: z.ZodType<TargetReleaseConfig, unknown>;
+/** @internal */
+export type TargetReleaseConfig$Outbound = {
+    id: string;
+    type: string;
+    [additionalProperties: string]: unknown;
+};
+/** @internal */
+export declare const TargetReleaseConfig$outboundSchema: z.ZodType<TargetReleaseConfig$Outbound, TargetReleaseConfig>;
+export declare function targetReleaseConfigToJSON(targetReleaseConfig: TargetReleaseConfig): string;
+export declare function targetReleaseConfigFromJSON(jsonString: string): SafeParseResult<TargetReleaseConfig, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseDependency$inboundSchema: z.ZodType<TargetReleaseDependency, unknown>;
+/** @internal */
+export type TargetReleaseDependency$Outbound = {
+    id: string;
+    type: string;
+};
+/** @internal */
+export declare const TargetReleaseDependency$outboundSchema: z.ZodType<TargetReleaseDependency$Outbound, TargetReleaseDependency>;
+export declare function targetReleaseDependencyToJSON(targetReleaseDependency: TargetReleaseDependency): string;
+export declare function targetReleaseDependencyFromJSON(jsonString: string): SafeParseResult<TargetReleaseDependency, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseLifecycle$inboundSchema: z.ZodEnum<typeof TargetReleaseLifecycle>;
+/** @internal */
+export declare const TargetReleaseLifecycle$outboundSchema: z.ZodEnum<typeof TargetReleaseLifecycle>;
+/** @internal */
+export declare const TargetReleaseResources$inboundSchema: z.ZodType<TargetReleaseResources, unknown>;
+/** @internal */
+export type TargetReleaseResources$Outbound = {
+    config: TargetReleaseConfig$Outbound;
+    dependencies: Array<TargetReleaseDependency$Outbound>;
+    enabledWhen?: string | null | undefined;
+    lifecycle: string;
+    remoteAccess?: boolean | undefined;
+};
+/** @internal */
+export declare const TargetReleaseResources$outboundSchema: z.ZodType<TargetReleaseResources$Outbound, TargetReleaseResources>;
+export declare function targetReleaseResourcesToJSON(targetReleaseResources: TargetReleaseResources): string;
+export declare function targetReleaseResourcesFromJSON(jsonString: string): SafeParseResult<TargetReleaseResources, SDKValidationError>;
+/** @internal */
+export declare const TargetReleaseSupportedPlatform$inboundSchema: z.ZodEnum<typeof TargetReleaseSupportedPlatform>;
+/** @internal */
+export declare const TargetReleaseSupportedPlatform$outboundSchema: z.ZodEnum<typeof TargetReleaseSupportedPlatform>;
+//# sourceMappingURL=targetreleasesupportedplatform.d.ts.map