@alienplatform/platform-api 3.3.29 → 3.3.31

package/esm/models/deploymentstate.d.ts

@@ -1,121 +1,2158 @@
 import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
-import { CurrentReleaseUnion, CurrentReleaseUnion$Outbound, DeploymentStateEnvironmentInfoUnion, DeploymentStateEnvironmentInfoUnion$Outbound, DeploymentStateErrorUnion, DeploymentStateErrorUnion$Outbound, DeploymentStatePlatform } from "./deploymentstatependingpreparedstackoverrideazurestack.js";
+import { CurrentReleaseUnion, CurrentReleaseUnion$Outbound, DeploymentStateEnvironmentInfoUnion, DeploymentStateEnvironmentInfoUnion$Outbound, DeploymentStateErrorUnion, DeploymentStateErrorUnion$Outbound, DeploymentStatePlatform } from "./deploymentstatependingpreparedstackdefaultunion.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import { DeploymentStateStatus, RuntimeMetadata, RuntimeMetadata$Outbound, StackState, StackState$Outbound, TargetReleaseInput, TargetReleaseInput$Outbound, TargetReleasePermissions, TargetReleasePermissions$Outbound, TargetReleaseResources, TargetReleaseResources$Outbound, TargetReleaseSupportedPlatform } from "./targetreleasesupportedplatform.js";
+import { DeploymentStateStatus, RuntimeMetadata, RuntimeMetadata$Outbound, StackState, StackState$Outbound, TargetReleaseInput, TargetReleaseInput$Outbound, TargetReleaseOperations, TargetReleaseOperations$Outbound } from "./targetreleaseoperations.js";
+export type TargetReleaseOperationsUnion = TargetReleaseOperations | string;
+export declare const TargetReleaseManagementEnum: {
+    readonly Auto: "auto";
+};
+export type TargetReleaseManagementEnum = ClosedEnum<typeof TargetReleaseManagementEnum>;
 /**
- * A bag of resources, unaware of any cloud.
+ * AWS-specific binding specification
  */
-export type TargetReleaseStack = {
+export type TargetReleaseOverrideAwResource = {
     /**
-     * Released Container resources whose image repositories are approved for
+     * 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
-     * containers created after installation.
+     * tag-on-create grant whose implied check AWS authorizes against no resource; the build
+     * refuses it anywhere else.
      */
-    dynamicContainerImageResources?: Array<string> | undefined;
+    notResources?: Array<string> | undefined;
     /**
-     * Exact image repositories approved for containers created after installation.
+     * 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
-     * The runtime API also requires an immutable SHA-256 digest.
+     * tag-on-create grant whose implied check AWS authorizes against no resource; the build
+     * refuses it anywhere else.
      */
-    dynamicContainerRepositories?: Array<string> | undefined;
+    notResources?: Array<string> | undefined;
     /**
-     * Unique identifier for the stack
+     * Resource ARNs to bind to
      */
-    id: string;
+    resources: Array<string>;
+};
+/**
+ * Generic binding configuration for permissions
+ */
+export type TargetReleaseOverrideAwBinding = {
     /**
-     * Input definitions required before setup or deployment can proceed.
+     * AWS-specific binding specification
      */
-    inputs?: Array<TargetReleaseInput> | undefined;
+    resource?: TargetReleaseOverrideAwResource | undefined;
     /**
-     * Combined permissions configuration that contains both profiles and management
+     * AWS-specific binding specification
      */
-    permissions?: TargetReleasePermissions | undefined;
+    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 = {
     /**
-     * Map of resource IDs to their configurations and lifecycle settings
+     * AWS IAM actions (only for AWS)
      */
-    resources: {
-        [k: string]: TargetReleaseResources;
-    };
+    actions?: Array<string> | null | undefined;
     /**
-     * Which platforms this stack supports. When None, all platforms are supported.
+     * Azure actions (only for Azure)
      */
-    supportedPlatforms?: Array<TargetReleaseSupportedPlatform> | null | undefined;
+    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;
 };
 /**
- * Release metadata
- *
- * @remarks
- *
- * Identifies a specific release version and includes the stack definition.
- * The deployment engine uses this to track which release is currently deployed
- * and which is the target.
+ * AWS-specific platform permission configuration
  */
-export type TargetRelease = {
+export type TargetReleaseOverrideAw = {
     /**
-     * Short description of the release
+     * Generic binding configuration for permissions
+     */
+    binding: TargetReleaseOverrideAwBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
      */
     description?: string | null | undefined;
     /**
-     * Release ID (e.g., rel_xyz). `None` for an observe deployment, which has no
-     *
-     * @remarks
-     * Alien-assigned release — the platform resolves a release from `version`.
+     * IAM effect. Defaults to Allow.
      */
-    releaseId?: string | null | undefined;
+    effect?: TargetReleaseOverrideEffect | undefined;
     /**
-     * A bag of resources, unaware of any cloud.
+     * Grant permissions for a specific cloud platform
      */
-    stack: TargetReleaseStack;
+    grant: TargetReleaseOverrideAwGrant;
     /**
-     * Version string (e.g., 2.1.0)
+     * Stable admin-facing label for this permission entry.
      */
-    version?: string | null | undefined;
+    label?: string | null | undefined;
 };
-export type TargetReleaseUnion = TargetRelease | string;
 /**
- * Current deployment state (includes releases)
+ * Azure-specific binding specification
  */
-export type DeploymentState = {
-    currentRelease?: CurrentReleaseUnion | null | undefined;
-    environmentInfo?: DeploymentStateEnvironmentInfoUnion | null | undefined;
-    error?: DeploymentStateErrorUnion | null | undefined;
+export type TargetReleaseOverrideAzureResource = {
     /**
-     * Represents the target cloud platform.
+     * Scope (subscription/resource group/resource level)
      */
-    platform: DeploymentStatePlatform;
+    scope: string;
+};
+/**
+ * Azure-specific binding specification
+ */
+export type TargetReleaseOverrideAzureStack = {
     /**
-     * Protocol version for cross-actor compatibility.
+     * 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
-     * All actors (manager, push client, agent) check this before stepping.
-     * Mismatched versions produce a clear error instead of silent corruption.
-     * See docs/02-manager/10-deployment-protocol.md.
+     * Key can be "*" for all resources or resource name for specific resource
      */
-    protocolVersion: number;
+    override: {
+        [k: string]: Array<TargetReleaseOverride | string>;
+    };
+};
+/**
+ * AWS-specific binding specification
+ */
+export type TargetReleaseExtendAwResource = {
     /**
-     * Whether a retry has been requested for a failed deployment
+     * 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
-     * When true and status is a failed state, the deployment system will retry failed resources
+     * tag-on-create grant whose implied check AWS authorizes against no resource; the build
+     * refuses it anywhere else.
      */
-    retryRequested?: boolean | undefined;
-    runtimeMetadata?: RuntimeMetadata | null | undefined;
-    stackState?: StackState | null | undefined;
+    notResources?: Array<string> | undefined;
     /**
-     * Deployment status in the deployment lifecycle.
+     * 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
-     *
-     * 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.
+     * tag-on-create grant whose implied check AWS authorizes against no resource; the build
+     * refuses it anywhere else.
      */
-    status: DeploymentStateStatus;
-    targetRelease?: TargetRelease | string | null | undefined;
+    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>;
+/**
+ * A bag of resources, unaware of any cloud.
+ */
+export type TargetReleaseStack = {
+    /**
+     * 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<TargetReleaseInput> | undefined;
+    operations?: TargetReleaseOperations | string | null | undefined;
+    /**
+     * Combined permissions configuration that contains both profiles and management
+     */
+    permissions?: TargetReleasePermissions | undefined;
+    /**
+     * Map of resource IDs to their configurations and lifecycle settings
+     */
+    resources: {
+        [k: string]: TargetReleaseResources;
+    };
+    /**
+     * Which platforms this stack supports. When None, all platforms are supported.
+     */
+    supportedPlatforms?: Array<TargetReleaseSupportedPlatform> | null | undefined;
+};
+/**
+ * Release metadata
+ *
+ * @remarks
+ *
+ * Identifies a specific release version and includes the stack definition.
+ * The deployment engine uses this to track which release is currently deployed
+ * and which is the target.
+ */
+export type TargetRelease = {
+    /**
+     * Short description of the release
+     */
+    description?: string | null | undefined;
+    /**
+     * Release ID (e.g., rel_xyz). `None` for an observe deployment, which has no
+     *
+     * @remarks
+     * Alien-assigned release — the platform resolves a release from `version`.
+     */
+    releaseId?: string | null | undefined;
+    /**
+     * A bag of resources, unaware of any cloud.
+     */
+    stack: TargetReleaseStack;
+    /**
+     * Version string (e.g., 2.1.0)
+     */
+    version?: string | null | undefined;
+};
+export type TargetReleaseUnion = TargetRelease | string;
+/**
+ * Current deployment state (includes releases)
+ */
+export type DeploymentState = {
+    currentRelease?: CurrentReleaseUnion | null | undefined;
+    environmentInfo?: DeploymentStateEnvironmentInfoUnion | null | undefined;
+    error?: DeploymentStateErrorUnion | null | undefined;
+    /**
+     * Represents the target cloud platform.
+     */
+    platform: DeploymentStatePlatform;
+    /**
+     * Protocol version for cross-actor compatibility.
+     *
+     * @remarks
+     * All actors (manager, push client, agent) check this before stepping.
+     * Mismatched versions produce a clear error instead of silent corruption.
+     * See docs/02-manager/10-deployment-protocol.md.
+     */
+    protocolVersion: number;
+    /**
+     * Whether a retry has been requested for a failed deployment
+     *
+     * @remarks
+     * When true and status is a failed state, the deployment system will retry failed resources
+     */
+    retryRequested?: boolean | undefined;
+    runtimeMetadata?: RuntimeMetadata | null | undefined;
+    stackState?: StackState | null | undefined;
+    /**
+     * 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.
+     */
+    status: DeploymentStateStatus;
+    targetRelease?: TargetRelease | string | null | undefined;
+};
+/** @internal */
+export declare const TargetReleaseOperationsUnion$inboundSchema: z.ZodType<TargetReleaseOperationsUnion, unknown>;
+/** @internal */
+export type TargetReleaseOperationsUnion$Outbound = TargetReleaseOperations$Outbound | string;
+/** @internal */
+export declare const TargetReleaseOperationsUnion$outboundSchema: z.ZodType<TargetReleaseOperationsUnion$Outbound, TargetReleaseOperationsUnion>;
+export declare function targetReleaseOperationsUnionToJSON(targetReleaseOperationsUnion: TargetReleaseOperationsUnion): string;
+export declare function targetReleaseOperationsUnionFromJSON(jsonString: string): SafeParseResult<TargetReleaseOperationsUnion, 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>;
 /** @internal */
 export declare const TargetReleaseStack$inboundSchema: z.ZodType<TargetReleaseStack, unknown>;
 /** @internal */
@@ -124,6 +2161,7 @@ export type TargetReleaseStack$Outbound = {
     dynamicContainerRepositories?: Array<string> | undefined;
     id: string;
     inputs?: Array<TargetReleaseInput$Outbound> | undefined;
+    operations?: TargetReleaseOperations$Outbound | string | null | undefined;
     permissions?: TargetReleasePermissions$Outbound | undefined;
     resources: {
         [k: string]: TargetReleaseResources$Outbound;