@alienplatform/platform-api 3.3.42 → 3.3.44

package/esm/models/deploymentstatependingpreparedstacktypestringlist.d.ts

@@ -0,0 +1,3598 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const CurrentReleaseTypeStringList: {
+    readonly StringList: "stringList";
+};
+export type CurrentReleaseTypeStringList = ClosedEnum<typeof CurrentReleaseTypeStringList>;
+export type CurrentReleaseDefaultStringList = {
+    type: CurrentReleaseTypeStringList;
+    /**
+     * String list default.
+     */
+    value: Array<string>;
+};
+export declare const CurrentReleaseTypeBoolean: {
+    readonly Boolean: "boolean";
+};
+export type CurrentReleaseTypeBoolean = ClosedEnum<typeof CurrentReleaseTypeBoolean>;
+export type CurrentReleaseDefaultBoolean = {
+    type: CurrentReleaseTypeBoolean;
+    /**
+     * Boolean default.
+     */
+    value: boolean;
+};
+export declare const CurrentReleaseTypeNumber: {
+    readonly Number: "number";
+};
+export type CurrentReleaseTypeNumber = ClosedEnum<typeof CurrentReleaseTypeNumber>;
+export type CurrentReleaseDefaultNumber = {
+    type: CurrentReleaseTypeNumber;
+    /**
+     * Number default.
+     */
+    value: string;
+};
+export declare const CurrentReleaseTypeString: {
+    readonly String: "string";
+};
+export type CurrentReleaseTypeString = ClosedEnum<typeof CurrentReleaseTypeString>;
+export type CurrentReleaseDefaultString = {
+    type: CurrentReleaseTypeString;
+    /**
+     * String default.
+     */
+    value: string;
+};
+export type CurrentReleaseDefaultUnion = CurrentReleaseDefaultString | CurrentReleaseDefaultNumber | CurrentReleaseDefaultBoolean | CurrentReleaseDefaultStringList | string;
+/**
+ * Environment variable handling for a stack input mapping.
+ */
+export declare const CurrentReleaseTypeEnvEnum: {
+    readonly Plain: "plain";
+    readonly Secret: "secret";
+};
+/**
+ * Environment variable handling for a stack input mapping.
+ */
+export type CurrentReleaseTypeEnvEnum = ClosedEnum<typeof CurrentReleaseTypeEnvEnum>;
+export type CurrentReleaseTypeUnion = CurrentReleaseTypeEnvEnum | string;
+/**
+ * How a resolved stack input is injected into runtime environment variables.
+ */
+export type CurrentReleaseEnv = {
+    /**
+     * Environment variable name.
+     */
+    name: string;
+    /**
+     * Target resource IDs or patterns. None means every env-capable resource.
+     */
+    targetResources?: Array<string> | null | undefined;
+    type?: CurrentReleaseTypeEnvEnum | string | null | undefined;
+};
+/**
+ * Asks Alien to generate a secret input's value.
+ *
+ * @remarks
+ *
+ * The value is an alphanumeric string (`A-Z`, `a-z`, `0-9`), so it is safe in
+ * connection strings, command lines and environment variables. It is generated
+ * once, when the deployment's input values are first resolved, and then kept
+ * with the deployment's other input values.
+ */
+export type CurrentReleaseGenerate = {
+    /**
+     * Number of characters to generate.
+     */
+    length: number;
+};
+export type CurrentReleaseGenerateUnion = CurrentReleaseGenerate | string;
+/**
+ * Primitive stack input kind.
+ */
+export declare const CurrentReleaseKind: {
+    readonly String: "string";
+    readonly Secret: "secret";
+    readonly Number: "number";
+    readonly Integer: "integer";
+    readonly Boolean: "boolean";
+    readonly Enum: "enum";
+    readonly StringList: "stringList";
+};
+/**
+ * Primitive stack input kind.
+ */
+export type CurrentReleaseKind = ClosedEnum<typeof CurrentReleaseKind>;
+/**
+ * Represents the target cloud platform.
+ */
+export declare const CurrentReleasePlatform: {
+    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 CurrentReleasePlatform = ClosedEnum<typeof CurrentReleasePlatform>;
+/**
+ * Who can provide a stack input value.
+ */
+export declare const CurrentReleaseProvidedBy: {
+    readonly Developer: "developer";
+    readonly Deployer: "deployer";
+};
+/**
+ * Who can provide a stack input value.
+ */
+export type CurrentReleaseProvidedBy = ClosedEnum<typeof CurrentReleaseProvidedBy>;
+/**
+ * Portable stack input validation constraints.
+ */
+export type CurrentReleaseValidation = {
+    /**
+     * Semantic format hint such as url.
+     */
+    format?: string | null | undefined;
+    /**
+     * Maximum number.
+     */
+    max?: string | null | undefined;
+    /**
+     * Maximum string-list items.
+     */
+    maxItems?: number | null | undefined;
+    /**
+     * Maximum string length.
+     */
+    maxLength?: number | null | undefined;
+    /**
+     * Minimum number.
+     */
+    min?: string | null | undefined;
+    /**
+     * Minimum string-list items.
+     */
+    minItems?: number | null | undefined;
+    /**
+     * Minimum string length.
+     */
+    minLength?: number | null | undefined;
+    /**
+     * Portable whole-value regex pattern.
+     */
+    pattern?: string | null | undefined;
+    /**
+     * Allowed string enum values.
+     */
+    values?: Array<string> | null | undefined;
+};
+export type CurrentReleaseValidationUnion = CurrentReleaseValidation | string;
+/**
+ * Stack input definition serialized into a release stack.
+ */
+export type CurrentReleaseInput = {
+    default?: CurrentReleaseDefaultString | CurrentReleaseDefaultNumber | CurrentReleaseDefaultBoolean | CurrentReleaseDefaultStringList | string | null | undefined;
+    /**
+     * Human-facing helper text.
+     */
+    description: string;
+    /**
+     * Runtime env-var mappings for v1 input resolution.
+     */
+    env?: Array<CurrentReleaseEnv> | undefined;
+    generate?: CurrentReleaseGenerate | string | null | undefined;
+    /**
+     * Stable input ID used by CLI/API calls.
+     */
+    id: string;
+    /**
+     * Primitive stack input kind.
+     */
+    kind: CurrentReleaseKind;
+    /**
+     * Human-facing field label.
+     */
+    label: string;
+    /**
+     * Example placeholder shown in UI.
+     */
+    placeholder?: string | null | undefined;
+    /**
+     * Platforms where this input applies.
+     */
+    platforms?: Array<CurrentReleasePlatform> | null | undefined;
+    /**
+     * Who can provide this value.
+     */
+    providedBy: Array<CurrentReleaseProvidedBy>;
+    /**
+     * Whether a resolved value is required before deployment can proceed.
+     */
+    required: boolean;
+    validation?: CurrentReleaseValidation | string | null | undefined;
+};
+/**
+ * Whether matching operations run without approval.
+ */
+export declare const CurrentReleaseCustomDecision: {
+    readonly Auto: "auto";
+    readonly Manual: "manual";
+};
+/**
+ * Whether matching operations run without approval.
+ */
+export type CurrentReleaseCustomDecision = ClosedEnum<typeof CurrentReleaseCustomDecision>;
+export type CurrentReleaseApprovalCustom = {
+    /**
+     * Whether matching operations run without approval.
+     */
+    decision: CurrentReleaseCustomDecision;
+    /**
+     * Highest risk tier (`read-only`, `mutating`, `destructive`) a wildcard
+     *
+     * @remarks
+     * access request for these operations may cover.
+     */
+    maxRisk?: string | null | undefined;
+};
+/**
+ * Whether matching operations run without approval.
+ */
+export declare const CurrentReleaseApprovalCustomEnum: {
+    readonly Auto: "auto";
+    readonly Manual: "manual";
+};
+/**
+ * Whether matching operations run without approval.
+ */
+export type CurrentReleaseApprovalCustomEnum = ClosedEnum<typeof CurrentReleaseApprovalCustomEnum>;
+/**
+ * Approval rule for the operations a pattern matches.
+ */
+export type CurrentReleaseCustomApprovalUnion = CurrentReleaseApprovalCustom | CurrentReleaseApprovalCustomEnum;
+export type CurrentReleaseSettingsCustom3 = {
+    /**
+     * Environment variable name.
+     */
+    env: string;
+};
+export type CurrentReleaseSettingsCustom2 = {
+    /**
+     * Resource ids in the same stack.
+     */
+    resources: Array<string>;
+};
+export type CurrentReleaseSettingsCustom1 = {
+    /**
+     * Stack input id.
+     */
+    input: string;
+};
+/**
+ * Value of one plugin setting.
+ */
+export type CurrentReleaseCustomSettingsUnion = CurrentReleaseSettingsCustom1 | CurrentReleaseSettingsCustom2 | CurrentReleaseSettingsCustom3 | string;
+/**
+ * A published custom plugin at an exact version.
+ */
+export type CurrentReleaseCustom = {
+    /**
+     * Approval rule per operation: an operation name, or `*` for all of them.
+     *
+     * @remarks
+     * Operations no rule matches need approval.
+     */
+    approval?: {
+        [k: string]: CurrentReleaseApprovalCustom | CurrentReleaseApprovalCustomEnum;
+    } | undefined;
+    /**
+     * Values for the settings the plugin's manifest declares.
+     */
+    settings?: {
+        [k: string]: CurrentReleaseSettingsCustom1 | CurrentReleaseSettingsCustom2 | CurrentReleaseSettingsCustom3 | string;
+    } | undefined;
+    /**
+     * Plugin name as published.
+     */
+    name: string;
+    /**
+     * Exact published version.
+     */
+    version: string;
+};
+/**
+ * Whether matching operations run without approval.
+ */
+export declare const CurrentReleasePluginsDecision: {
+    readonly Auto: "auto";
+    readonly Manual: "manual";
+};
+/**
+ * Whether matching operations run without approval.
+ */
+export type CurrentReleasePluginsDecision = ClosedEnum<typeof CurrentReleasePluginsDecision>;
+export type CurrentReleaseApprovalPlugins = {
+    /**
+     * Whether matching operations run without approval.
+     */
+    decision: CurrentReleasePluginsDecision;
+    /**
+     * Highest risk tier (`read-only`, `mutating`, `destructive`) a wildcard
+     *
+     * @remarks
+     * access request for these operations may cover.
+     */
+    maxRisk?: string | null | undefined;
+};
+/**
+ * Whether matching operations run without approval.
+ */
+export declare const CurrentReleaseApprovalPluginsEnum: {
+    readonly Auto: "auto";
+    readonly Manual: "manual";
+};
+/**
+ * Whether matching operations run without approval.
+ */
+export type CurrentReleaseApprovalPluginsEnum = ClosedEnum<typeof CurrentReleaseApprovalPluginsEnum>;
+/**
+ * Approval rule for the operations a pattern matches.
+ */
+export type CurrentReleasePluginsApprovalUnion = CurrentReleaseApprovalPlugins | CurrentReleaseApprovalPluginsEnum;
+export type CurrentReleaseSettingsPlugins3 = {
+    /**
+     * Environment variable name.
+     */
+    env: string;
+};
+export type CurrentReleaseSettingsPlugins2 = {
+    /**
+     * Resource ids in the same stack.
+     */
+    resources: Array<string>;
+};
+export type CurrentReleaseSettingsPlugins1 = {
+    /**
+     * Stack input id.
+     */
+    input: string;
+};
+/**
+ * Value of one plugin setting.
+ */
+export type CurrentReleasePluginsSettingsUnion = CurrentReleaseSettingsPlugins1 | CurrentReleaseSettingsPlugins2 | CurrentReleaseSettingsPlugins3 | string;
+/**
+ * Settings and approval rules for one plugin.
+ */
+export type CurrentReleasePlugins = {
+    /**
+     * Approval rule per operation: an operation name, or `*` for all of them.
+     *
+     * @remarks
+     * Operations no rule matches need approval.
+     */
+    approval?: {
+        [k: string]: CurrentReleaseApprovalPlugins | CurrentReleaseApprovalPluginsEnum;
+    } | undefined;
+    /**
+     * Values for the settings the plugin's manifest declares.
+     */
+    settings?: {
+        [k: string]: CurrentReleaseSettingsPlugins1 | CurrentReleaseSettingsPlugins2 | CurrentReleaseSettingsPlugins3 | string;
+    } | undefined;
+};
+/**
+ * Operations declared by a stack, or by an Operator installed on its own.
+ */
+export type CurrentReleaseOperations = {
+    /**
+     * Published custom plugins, pinned to exact versions.
+     */
+    custom?: Array<CurrentReleaseCustom> | undefined;
+    /**
+     * Built-in plugins, by plugin name.
+     */
+    plugins?: {
+        [k: string]: CurrentReleasePlugins;
+    } | undefined;
+};
+export type CurrentReleaseOperationsUnion = CurrentReleaseOperations | string;
+export declare const CurrentReleaseManagementEnum: {
+    readonly Auto: "auto";
+};
+export type CurrentReleaseManagementEnum = ClosedEnum<typeof CurrentReleaseManagementEnum>;
+/**
+ * AWS-specific binding specification
+ */
+export type CurrentReleaseOverrideAwResource = {
+    /**
+     * 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 CurrentReleaseOverrideAwStack = {
+    /**
+     * 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 CurrentReleaseOverrideAwBinding = {
+    /**
+     * AWS-specific binding specification
+     */
+    resource?: CurrentReleaseOverrideAwResource | undefined;
+    /**
+     * AWS-specific binding specification
+     */
+    stack?: CurrentReleaseOverrideAwStack | undefined;
+};
+/**
+ * IAM effect. Defaults to Allow.
+ */
+export declare const CurrentReleaseOverrideEffect: {
+    readonly Allow: "Allow";
+    readonly Deny: "Deny";
+};
+/**
+ * IAM effect. Defaults to Allow.
+ */
+export type CurrentReleaseOverrideEffect = ClosedEnum<typeof CurrentReleaseOverrideEffect>;
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type CurrentReleaseOverrideAwGrant = {
+    /**
+     * 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 CurrentReleaseOverrideAw = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: CurrentReleaseOverrideAwBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * IAM effect. Defaults to Allow.
+     */
+    effect?: CurrentReleaseOverrideEffect | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: CurrentReleaseOverrideAwGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * Azure-specific binding specification
+ */
+export type CurrentReleaseOverrideAzureResource = {
+    /**
+     * Scope (subscription/resource group/resource level)
+     */
+    scope: string;
+};
+/**
+ * Azure-specific binding specification
+ */
+export type CurrentReleaseOverrideAzureStack = {
+    /**
+     * Scope (subscription/resource group/resource level)
+     */
+    scope: string;
+};
+/**
+ * Generic binding configuration for permissions
+ */
+export type CurrentReleaseOverrideAzureBinding = {
+    /**
+     * Azure-specific binding specification
+     */
+    resource?: CurrentReleaseOverrideAzureResource | undefined;
+    /**
+     * Azure-specific binding specification
+     */
+    stack?: CurrentReleaseOverrideAzureStack | undefined;
+};
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type CurrentReleaseOverrideAzureGrant = {
+    /**
+     * 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 CurrentReleaseOverrideAzure = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: CurrentReleaseOverrideAzureBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: CurrentReleaseOverrideAzureGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * GCP IAM condition
+ */
+export type CurrentReleaseOverrideConditionResource = {
+    expression: string;
+    title: string;
+};
+export type CurrentReleaseOverrideResourceConditionUnion = CurrentReleaseOverrideConditionResource | string;
+/**
+ * GCP-specific binding specification
+ */
+export type CurrentReleaseOverrideGcpResource = {
+    condition?: CurrentReleaseOverrideConditionResource | string | null | undefined;
+    /**
+     * Scope (project/resource level)
+     */
+    scope: string;
+};
+/**
+ * GCP IAM condition
+ */
+export type CurrentReleaseOverrideCondition = {
+    expression: string;
+    title: string;
+};
+export type CurrentReleaseOverrideConditionUnion = CurrentReleaseOverrideCondition | string;
+/**
+ * GCP-specific binding specification
+ */
+export type CurrentReleaseOverrideGcpStack = {
+    condition?: CurrentReleaseOverrideCondition | string | null | undefined;
+    /**
+     * Scope (project/resource level)
+     */
+    scope: string;
+};
+/**
+ * Generic binding configuration for permissions
+ */
+export type CurrentReleaseOverrideGcpBinding = {
+    /**
+     * GCP-specific binding specification
+     */
+    resource?: CurrentReleaseOverrideGcpResource | undefined;
+    /**
+     * GCP-specific binding specification
+     */
+    stack?: CurrentReleaseOverrideGcpStack | undefined;
+};
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type CurrentReleaseOverrideGcpGrant = {
+    /**
+     * 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 CurrentReleaseOverrideGcp = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: CurrentReleaseOverrideGcpBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: CurrentReleaseOverrideGcpGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * Platform-specific permission configurations
+ */
+export type CurrentReleaseOverridePlatforms = {
+    /**
+     * AWS permission configurations
+     */
+    aws?: Array<CurrentReleaseOverrideAw> | null | undefined;
+    /**
+     * Azure permission configurations
+     */
+    azure?: Array<CurrentReleaseOverrideAzure> | null | undefined;
+    /**
+     * GCP permission configurations
+     */
+    gcp?: Array<CurrentReleaseOverrideGcp> | null | undefined;
+};
+/**
+ * A permission set that can be applied across different cloud platforms
+ */
+export type CurrentReleaseOverride = {
+    /**
+     * 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: CurrentReleaseOverridePlatforms;
+};
+/**
+ * Reference to a permission set - either by name or inline definition
+ */
+export type CurrentReleaseOverrideUnion = CurrentReleaseOverride | string;
+export type CurrentReleaseManagement2 = {
+    /**
+     * Permission profile that maps resources to permission sets
+     *
+     * @remarks
+     * Key can be "*" for all resources or resource name for specific resource
+     */
+    override: {
+        [k: string]: Array<CurrentReleaseOverride | string>;
+    };
+};
+/**
+ * AWS-specific binding specification
+ */
+export type CurrentReleaseExtendAwResource = {
+    /**
+     * 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 CurrentReleaseExtendAwStack = {
+    /**
+     * 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 CurrentReleaseExtendAwBinding = {
+    /**
+     * AWS-specific binding specification
+     */
+    resource?: CurrentReleaseExtendAwResource | undefined;
+    /**
+     * AWS-specific binding specification
+     */
+    stack?: CurrentReleaseExtendAwStack | undefined;
+};
+/**
+ * IAM effect. Defaults to Allow.
+ */
+export declare const CurrentReleaseExtendEffect: {
+    readonly Allow: "Allow";
+    readonly Deny: "Deny";
+};
+/**
+ * IAM effect. Defaults to Allow.
+ */
+export type CurrentReleaseExtendEffect = ClosedEnum<typeof CurrentReleaseExtendEffect>;
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type CurrentReleaseExtendAwGrant = {
+    /**
+     * 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 CurrentReleaseExtendAw = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: CurrentReleaseExtendAwBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * IAM effect. Defaults to Allow.
+     */
+    effect?: CurrentReleaseExtendEffect | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: CurrentReleaseExtendAwGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * Azure-specific binding specification
+ */
+export type CurrentReleaseExtendAzureResource = {
+    /**
+     * Scope (subscription/resource group/resource level)
+     */
+    scope: string;
+};
+/**
+ * Azure-specific binding specification
+ */
+export type CurrentReleaseExtendAzureStack = {
+    /**
+     * Scope (subscription/resource group/resource level)
+     */
+    scope: string;
+};
+/**
+ * Generic binding configuration for permissions
+ */
+export type CurrentReleaseExtendAzureBinding = {
+    /**
+     * Azure-specific binding specification
+     */
+    resource?: CurrentReleaseExtendAzureResource | undefined;
+    /**
+     * Azure-specific binding specification
+     */
+    stack?: CurrentReleaseExtendAzureStack | undefined;
+};
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type CurrentReleaseExtendAzureGrant = {
+    /**
+     * 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 CurrentReleaseExtendAzure = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: CurrentReleaseExtendAzureBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: CurrentReleaseExtendAzureGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * GCP IAM condition
+ */
+export type CurrentReleaseExtendConditionResource = {
+    expression: string;
+    title: string;
+};
+export type CurrentReleaseExtendResourceConditionUnion = CurrentReleaseExtendConditionResource | string;
+/**
+ * GCP-specific binding specification
+ */
+export type CurrentReleaseExtendGcpResource = {
+    condition?: CurrentReleaseExtendConditionResource | string | null | undefined;
+    /**
+     * Scope (project/resource level)
+     */
+    scope: string;
+};
+/**
+ * GCP IAM condition
+ */
+export type CurrentReleaseExtendCondition = {
+    expression: string;
+    title: string;
+};
+export type CurrentReleaseExtendConditionUnion = CurrentReleaseExtendCondition | string;
+/**
+ * GCP-specific binding specification
+ */
+export type CurrentReleaseExtendGcpStack = {
+    condition?: CurrentReleaseExtendCondition | string | null | undefined;
+    /**
+     * Scope (project/resource level)
+     */
+    scope: string;
+};
+/**
+ * Generic binding configuration for permissions
+ */
+export type CurrentReleaseExtendGcpBinding = {
+    /**
+     * GCP-specific binding specification
+     */
+    resource?: CurrentReleaseExtendGcpResource | undefined;
+    /**
+     * GCP-specific binding specification
+     */
+    stack?: CurrentReleaseExtendGcpStack | undefined;
+};
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type CurrentReleaseExtendGcpGrant = {
+    /**
+     * 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 CurrentReleaseExtendGcp = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: CurrentReleaseExtendGcpBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: CurrentReleaseExtendGcpGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * Platform-specific permission configurations
+ */
+export type CurrentReleaseExtendPlatforms = {
+    /**
+     * AWS permission configurations
+     */
+    aws?: Array<CurrentReleaseExtendAw> | null | undefined;
+    /**
+     * Azure permission configurations
+     */
+    azure?: Array<CurrentReleaseExtendAzure> | null | undefined;
+    /**
+     * GCP permission configurations
+     */
+    gcp?: Array<CurrentReleaseExtendGcp> | null | undefined;
+};
+/**
+ * A permission set that can be applied across different cloud platforms
+ */
+export type CurrentReleaseExtend = {
+    /**
+     * 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: CurrentReleaseExtendPlatforms;
+};
+/**
+ * Reference to a permission set - either by name or inline definition
+ */
+export type CurrentReleaseExtendUnion = CurrentReleaseExtend | string;
+export type CurrentReleaseManagement1 = {
+    /**
+     * 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<CurrentReleaseExtend | string>;
+    };
+};
+/**
+ * Management permissions configuration for stack management access
+ */
+export type CurrentReleaseManagementUnion = CurrentReleaseManagement1 | CurrentReleaseManagement2 | CurrentReleaseManagementEnum;
+/**
+ * AWS-specific binding specification
+ */
+export type CurrentReleaseProfileAwResource = {
+    /**
+     * 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 CurrentReleaseProfileAwStack = {
+    /**
+     * 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 CurrentReleaseProfileAwBinding = {
+    /**
+     * AWS-specific binding specification
+     */
+    resource?: CurrentReleaseProfileAwResource | undefined;
+    /**
+     * AWS-specific binding specification
+     */
+    stack?: CurrentReleaseProfileAwStack | undefined;
+};
+/**
+ * IAM effect. Defaults to Allow.
+ */
+export declare const CurrentReleaseProfileEffect: {
+    readonly Allow: "Allow";
+    readonly Deny: "Deny";
+};
+/**
+ * IAM effect. Defaults to Allow.
+ */
+export type CurrentReleaseProfileEffect = ClosedEnum<typeof CurrentReleaseProfileEffect>;
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type CurrentReleaseProfileAwGrant = {
+    /**
+     * 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 CurrentReleaseProfileAw = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: CurrentReleaseProfileAwBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * IAM effect. Defaults to Allow.
+     */
+    effect?: CurrentReleaseProfileEffect | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: CurrentReleaseProfileAwGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * Azure-specific binding specification
+ */
+export type CurrentReleaseProfileAzureResource = {
+    /**
+     * Scope (subscription/resource group/resource level)
+     */
+    scope: string;
+};
+/**
+ * Azure-specific binding specification
+ */
+export type CurrentReleaseProfileAzureStack = {
+    /**
+     * Scope (subscription/resource group/resource level)
+     */
+    scope: string;
+};
+/**
+ * Generic binding configuration for permissions
+ */
+export type CurrentReleaseProfileAzureBinding = {
+    /**
+     * Azure-specific binding specification
+     */
+    resource?: CurrentReleaseProfileAzureResource | undefined;
+    /**
+     * Azure-specific binding specification
+     */
+    stack?: CurrentReleaseProfileAzureStack | undefined;
+};
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type CurrentReleaseProfileAzureGrant = {
+    /**
+     * 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 CurrentReleaseProfileAzure = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: CurrentReleaseProfileAzureBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: CurrentReleaseProfileAzureGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * GCP IAM condition
+ */
+export type CurrentReleaseProfileConditionResource = {
+    expression: string;
+    title: string;
+};
+export type CurrentReleaseProfileResourceConditionUnion = CurrentReleaseProfileConditionResource | string;
+/**
+ * GCP-specific binding specification
+ */
+export type CurrentReleaseProfileGcpResource = {
+    condition?: CurrentReleaseProfileConditionResource | string | null | undefined;
+    /**
+     * Scope (project/resource level)
+     */
+    scope: string;
+};
+/**
+ * GCP IAM condition
+ */
+export type CurrentReleaseProfileCondition = {
+    expression: string;
+    title: string;
+};
+export type CurrentReleaseProfileConditionUnion = CurrentReleaseProfileCondition | string;
+/**
+ * GCP-specific binding specification
+ */
+export type CurrentReleaseProfileGcpStack = {
+    condition?: CurrentReleaseProfileCondition | string | null | undefined;
+    /**
+     * Scope (project/resource level)
+     */
+    scope: string;
+};
+/**
+ * Generic binding configuration for permissions
+ */
+export type CurrentReleaseProfileGcpBinding = {
+    /**
+     * GCP-specific binding specification
+     */
+    resource?: CurrentReleaseProfileGcpResource | undefined;
+    /**
+     * GCP-specific binding specification
+     */
+    stack?: CurrentReleaseProfileGcpStack | undefined;
+};
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type CurrentReleaseProfileGcpGrant = {
+    /**
+     * 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 CurrentReleaseProfileGcp = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: CurrentReleaseProfileGcpBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: CurrentReleaseProfileGcpGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * Platform-specific permission configurations
+ */
+export type CurrentReleaseProfilePlatforms = {
+    /**
+     * AWS permission configurations
+     */
+    aws?: Array<CurrentReleaseProfileAw> | null | undefined;
+    /**
+     * Azure permission configurations
+     */
+    azure?: Array<CurrentReleaseProfileAzure> | null | undefined;
+    /**
+     * GCP permission configurations
+     */
+    gcp?: Array<CurrentReleaseProfileGcp> | null | undefined;
+};
+/**
+ * A permission set that can be applied across different cloud platforms
+ */
+export type CurrentReleaseProfile = {
+    /**
+     * 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: CurrentReleaseProfilePlatforms;
+};
+/**
+ * Reference to a permission set - either by name or inline definition
+ */
+export type CurrentReleaseProfileUnion = CurrentReleaseProfile | string;
+/**
+ * Combined permissions configuration that contains both profiles and management
+ */
+export type CurrentReleasePermissions = {
+    /**
+     * Management permissions configuration for stack management access
+     */
+    management?: CurrentReleaseManagement1 | CurrentReleaseManagement2 | CurrentReleaseManagementEnum | 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<CurrentReleaseProfile | 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 CurrentReleaseConfig = {
+    /**
+     * 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 CurrentReleaseDependency = {
+    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 CurrentReleaseLifecycle: {
+    readonly Frozen: "frozen";
+    readonly Live: "live";
+};
+/**
+ * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
+ */
+export type CurrentReleaseLifecycle = ClosedEnum<typeof CurrentReleaseLifecycle>;
+export type CurrentReleaseResources = {
+    /**
+     * 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: CurrentReleaseConfig;
+    /**
+     * Additional dependencies for this resource beyond those defined in the resource itself.
+     *
+     * @remarks
+     * The total dependencies are: resource.get_dependencies() + this list
+     */
+    dependencies: Array<CurrentReleaseDependency>;
+    /**
+     * Authored purpose, displayed as plain text. Does not affect resource configuration.
+     */
+    description?: string | null | undefined;
+    /**
+     * Optional human-readable name. The stable resource ID is the display fallback.
+     */
+    displayName?: string | null | undefined;
+    /**
+     * 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: CurrentReleaseLifecycle;
+    /**
+     * 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 CurrentReleaseSupportedPlatform: {
+    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 CurrentReleaseSupportedPlatform = ClosedEnum<typeof CurrentReleaseSupportedPlatform>;
+/**
+ * A bag of resources, unaware of any cloud.
+ */
+export type CurrentReleaseStack = {
+    /**
+     * 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<CurrentReleaseInput> | undefined;
+    operations?: CurrentReleaseOperations | string | null | undefined;
+    /**
+     * Combined permissions configuration that contains both profiles and management
+     */
+    permissions?: CurrentReleasePermissions | undefined;
+    /**
+     * Map of resource IDs to their configurations and lifecycle settings
+     */
+    resources: {
+        [k: string]: CurrentReleaseResources;
+    };
+    /**
+     * Which platforms this stack supports. When None, all platforms are supported.
+     */
+    supportedPlatforms?: Array<CurrentReleaseSupportedPlatform> | 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 CurrentRelease = {
+    /**
+     * 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: CurrentReleaseStack;
+    /**
+     * Version string (e.g., 2.1.0)
+     */
+    version?: string | null | undefined;
+};
+export type CurrentReleaseUnion = CurrentRelease | string;
+export declare const DeploymentStatePlatformTest: {
+    readonly Test: "test";
+};
+export type DeploymentStatePlatformTest = ClosedEnum<typeof DeploymentStatePlatformTest>;
+/**
+ * Test platform environment information (mock)
+ */
+export type DeploymentStateEnvironmentInfoTest = {
+    /**
+     * Test identifier for this environment
+     */
+    testId: string;
+    platform: DeploymentStatePlatformTest;
+};
+export declare const DeploymentStatePlatformLocal: {
+    readonly Local: "local";
+};
+export type DeploymentStatePlatformLocal = ClosedEnum<typeof DeploymentStatePlatformLocal>;
+/**
+ * Local platform environment information
+ */
+export type DeploymentStateEnvironmentInfoLocal = {
+    /**
+     * Architecture (e.g., "x86_64", "aarch64")
+     */
+    arch: string;
+    /**
+     * Hostname of the machine running the deployment
+     */
+    hostname: string;
+    /**
+     * Operating system (e.g., "linux", "macos", "windows")
+     */
+    os: string;
+    platform: DeploymentStatePlatformLocal;
+};
+export declare const DeploymentStatePlatformAzure: {
+    readonly Azure: "azure";
+};
+export type DeploymentStatePlatformAzure = ClosedEnum<typeof DeploymentStatePlatformAzure>;
+/**
+ * Azure-specific environment information
+ */
+export type DeploymentStateEnvironmentInfoAzure = {
+    /**
+     * Azure location/region
+     */
+    location: string;
+    /**
+     * Azure subscription ID
+     */
+    subscriptionId: string;
+    /**
+     * Azure tenant ID
+     */
+    tenantId: string;
+    platform: DeploymentStatePlatformAzure;
+};
+export declare const DeploymentStatePlatformGcp: {
+    readonly Gcp: "gcp";
+};
+export type DeploymentStatePlatformGcp = ClosedEnum<typeof DeploymentStatePlatformGcp>;
+/**
+ * GCP-specific environment information
+ */
+export type DeploymentStateEnvironmentInfoGcp = {
+    /**
+     * GCP project ID (e.g., "my-project")
+     */
+    projectId: string;
+    /**
+     * GCP project number (e.g., "123456789012")
+     */
+    projectNumber: string;
+    /**
+     * GCP region
+     */
+    region: string;
+    platform: DeploymentStatePlatformGcp;
+};
+export declare const DeploymentStatePlatformAws: {
+    readonly Aws: "aws";
+};
+export type DeploymentStatePlatformAws = ClosedEnum<typeof DeploymentStatePlatformAws>;
+/**
+ * AWS-specific environment information
+ */
+export type DeploymentStateEnvironmentInfoAws = {
+    /**
+     * AWS account ID
+     */
+    accountId: string;
+    /**
+     * AWS region
+     */
+    region: string;
+    platform: DeploymentStatePlatformAws;
+};
+export type DeploymentStateEnvironmentInfoUnion = DeploymentStateEnvironmentInfoGcp | DeploymentStateEnvironmentInfoAzure | DeploymentStateEnvironmentInfoLocal | DeploymentStateEnvironmentInfoAws | DeploymentStateEnvironmentInfoTest | string;
+/**
+ * Canonical error container that provides a structured way to represent errors
+ *
+ * @remarks
+ * with rich metadata including error codes, human-readable messages, context,
+ * and chaining capabilities for error propagation.
+ *
+ * This struct is designed to be both machine-readable and user-friendly,
+ * supporting serialization for API responses and detailed error reporting
+ * in distributed systems.
+ */
+export type DeploymentStateError = {
+    /**
+     * A unique identifier for the type of error.
+     *
+     * @remarks
+     *
+     * This should be a short, machine-readable string that can be used
+     * by clients to programmatically handle different error types.
+     * Examples: "NOT_FOUND", "VALIDATION_ERROR", "TIMEOUT"
+     */
+    code: string;
+    /**
+     * Additional diagnostic information about the error context.
+     *
+     * @remarks
+     *
+     * This optional field can contain structured data providing more details
+     * about the error, such as validation errors, request parameters that
+     * caused the issue, or other relevant context information.
+     */
+    context?: any | null | undefined;
+    /**
+     * Optional human-facing remediation hint.
+     */
+    hint?: string | null | undefined;
+    /**
+     * HTTP status code for this error.
+     *
+     * @remarks
+     *
+     * Used when converting the error to an HTTP response. If None, falls back to
+     * the error type's default status code or 500.
+     */
+    httpStatusCode?: number | null | undefined;
+    /**
+     * Indicates if this is an internal error that should not be exposed to users.
+     *
+     * @remarks
+     *
+     * When `true`, this error contains sensitive information or implementation
+     * details that should not be shown to end-users. Such errors should be
+     * logged for debugging but replaced with generic error messages in responses.
+     */
+    internal: boolean;
+    /**
+     * Human-readable error message.
+     *
+     * @remarks
+     *
+     * This message should be clear and actionable for developers or end-users,
+     * providing context about what went wrong and potentially how to fix it.
+     */
+    message: string;
+    /**
+     * Indicates whether the operation that caused the error should be retried.
+     *
+     * @remarks
+     *
+     * When `true`, the error is transient and the operation might succeed
+     * if attempted again. When `false`, retrying the same operation is
+     * unlikely to succeed without changes.
+     */
+    retryable?: boolean | undefined;
+    /**
+     * The underlying error that caused this error, creating an error chain.
+     *
+     * @remarks
+     *
+     * This allows for proper error propagation and debugging by maintaining
+     * the full context of how an error occurred through multiple layers
+     * of an application.
+     */
+    source?: any | null | undefined;
+};
+export type DeploymentStateErrorUnion = DeploymentStateError | string;
+/**
+ * Represents the target cloud platform.
+ */
+export declare const DeploymentStatePlatform: {
+    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 DeploymentStatePlatform = ClosedEnum<typeof DeploymentStatePlatform>;
+/**
+ * Changing phase starts a new window instead of carrying a previous outage forward.
+ */
+export declare const DeploymentStateCredentialRetryStatus: {
+    readonly Pending: "pending";
+    readonly PreflightsFailed: "preflights-failed";
+    readonly InitialSetup: "initial-setup";
+    readonly InitialSetupFailed: "initial-setup-failed";
+    readonly Provisioning: "provisioning";
+    readonly WaitingForMachines: "waiting-for-machines";
+    readonly WaitingForSecrets: "waiting-for-secrets";
+    readonly ProvisioningFailed: "provisioning-failed";
+    readonly Running: "running";
+    readonly RefreshFailed: "refresh-failed";
+    readonly UpdatePending: "update-pending";
+    readonly Updating: "updating";
+    readonly UpdateFailed: "update-failed";
+    readonly DeletePending: "delete-pending";
+    readonly Deleting: "deleting";
+    readonly DeleteFailed: "delete-failed";
+    readonly TeardownRequired: "teardown-required";
+    readonly TeardownFailed: "teardown-failed";
+    readonly RetentionRequired: "retention-required";
+    readonly Retained: "retained";
+    readonly Deleted: "deleted";
+    readonly Error: "error";
+};
+/**
+ * Changing phase starts a new window instead of carrying a previous outage forward.
+ */
+export type DeploymentStateCredentialRetryStatus = ClosedEnum<typeof DeploymentStateCredentialRetryStatus>;
+/**
+ * A credential outage's durable retry window, scoped to its deployment phase.
+ */
+export type DeploymentStateCredentialRetry = {
+    /**
+     * First credential failure in this phase; subsequent attempts keep this timestamp.
+     */
+    startedAt: Date;
+    /**
+     * Changing phase starts a new window instead of carrying a previous outage forward.
+     */
+    status: DeploymentStateCredentialRetryStatus;
+};
+/**
+ * Bounded credential retry state shared by all deployment drivers.
+ */
+export type DeploymentStateCredentialRetryUnion = DeploymentStateCredentialRetry | string;
+/**
+ * Explicit disposition of durable data when deleting a deployment.
+ *
+ * @remarks
+ * Missing values from older checkpoints always preserve data.
+ */
+export declare const DeploymentStateDeletionPolicy: {
+    readonly Retain: "retain";
+    readonly Erase: "erase";
+};
+/**
+ * Explicit disposition of durable data when deleting a deployment.
+ *
+ * @remarks
+ * Missing values from older checkpoints always preserve data.
+ */
+export type DeploymentStateDeletionPolicy = ClosedEnum<typeof DeploymentStateDeletionPolicy>;
+/**
+ * Commands for a shell family. Values are never sent to the control plane.
+ */
+export type DeploymentStateUnix = {
+    /**
+     * Command with a visible value placeholder; shell history can retain it.
+     */
+    inline: string;
+    /**
+     * Hidden-input command, without the value in shell history or process arguments.
+     */
+    prompt: string;
+};
+/**
+ * Commands for a shell family. Values are never sent to the control plane.
+ */
+export type DeploymentStateWindows = {
+    /**
+     * Command with a visible value placeholder; shell history can retain it.
+     */
+    inline: string;
+    /**
+     * Hidden-input command, without the value in shell history or process arguments.
+     */
+    prompt: string;
+};
+/**
+ * Shell-specific instructions generated beside the secret location.
+ */
+export type DeploymentStateCommands = {
+    /**
+     * Read-only identity check, valid in both shell families.
+     */
+    checkCommand?: string | null | undefined;
+    /**
+     * Expected account, project, subscription or Kubernetes namespace.
+     */
+    target?: string | null | undefined;
+    /**
+     * Commands for a shell family. Values are never sent to the control plane.
+     */
+    unix: DeploymentStateUnix;
+    /**
+     * Commands for a shell family. Values are never sent to the control plane.
+     */
+    windows: DeploymentStateWindows;
+};
+export type DeploymentStateCommandsUnion = DeploymentStateCommands | string;
+/**
+ * The secret store a deployer writes a vault-native secret into.
+ */
+export declare const DeploymentStateStore: {
+    readonly AwsParameterStore: "aws-parameter-store";
+    readonly GcpSecretManager: "gcp-secret-manager";
+    readonly AzureKeyVault: "azure-key-vault";
+    readonly KubernetesSecret: "kubernetes-secret";
+    readonly LocalVault: "local-vault";
+};
+/**
+ * The secret store a deployer writes a vault-native secret into.
+ */
+export type DeploymentStateStore = ClosedEnum<typeof DeploymentStateStore>;
+/**
+ * Where a deployer writes a vault-native secret.
+ */
+export type DeploymentStateLocation = {
+    /**
+     * Command that prompts without echoing and writes the value through stdin.
+     */
+    cliCommand: string;
+    commands?: DeploymentStateCommands | string | null | undefined;
+    /**
+     * Cloud console page where the secret is created, when the store has one.
+     */
+    consoleUrl?: string | null | undefined;
+    /**
+     * Command that deletes the secret. Deleting a deployment keeps the
+     *
+     * @remarks
+     * secrets the deployer wrote, since Alien never owned their values.
+     */
+    deleteCommand?: string | null | undefined;
+    /**
+     * Full name of the secret in that store.
+     */
+    name: string;
+    /**
+     * The secret store a deployer writes a vault-native secret into.
+     */
+    store: DeploymentStateStore;
+    /**
+     * The Azure Key Vault that holds the secret. Other stores resolve `name`
+     *
+     * @remarks
+     * in the stack's own account or project.
+     */
+    vaultName?: string | null | undefined;
+};
+/**
+ * Whether a deployer secret slot holds a usable value. Alien learns this from
+ *
+ * @remarks
+ * metadata only and never reads the value.
+ */
+export declare const DeploymentStateDeployerSecretStatus: {
+    readonly Present: "present";
+    readonly Missing: "missing";
+    readonly Invalid: "invalid";
+};
+/**
+ * Whether a deployer secret slot holds a usable value. Alien learns this from
+ *
+ * @remarks
+ * metadata only and never reads the value.
+ */
+export type DeploymentStateDeployerSecretStatus = ClosedEnum<typeof DeploymentStateDeployerSecretStatus>;
+/**
+ * The state of one deployer secret slot, reported with the deployment.
+ */
+export type DeploymentStateDeployerSecret = {
+    /**
+     * Stack input id.
+     */
+    inputId: string;
+    /**
+     * The input's label.
+     */
+    label: string;
+    /**
+     * Where a deployer writes a vault-native secret.
+     */
+    location: DeploymentStateLocation;
+    /**
+     * Why the slot is invalid.
+     */
+    message?: string | null | undefined;
+    /**
+     * Whether the workload cannot start without it.
+     */
+    required: boolean;
+    /**
+     * Whether a deployer secret slot holds a usable value. Alien learns this from
+     *
+     * @remarks
+     * metadata only and never reads the value.
+     */
+    status: DeploymentStateDeployerSecretStatus;
+    /**
+     * The secret store's version of the present value (never the value or a
+     *
+     * @remarks
+     * hash of it). A new version reaches workloads with the next update.
+     */
+    version?: string | null | undefined;
+};
+/**
+ * Actor that owns structural work during the initial setup phase.
+ */
+export declare const DeploymentStateInitialSetupAuthority: {
+    readonly ImportedHandoff: "importedHandoff";
+    readonly DirectSetup: "directSetup";
+};
+/**
+ * Actor that owns structural work during the initial setup phase.
+ */
+export type DeploymentStateInitialSetupAuthority = ClosedEnum<typeof DeploymentStateInitialSetupAuthority>;
+export declare const DeploymentStatePendingPreparedStackTypeStringList: {
+    readonly StringList: "stringList";
+};
+export type DeploymentStatePendingPreparedStackTypeStringList = ClosedEnum<typeof DeploymentStatePendingPreparedStackTypeStringList>;
+/** @internal */
+export declare const CurrentReleaseTypeStringList$inboundSchema: z.ZodEnum<typeof CurrentReleaseTypeStringList>;
+/** @internal */
+export declare const CurrentReleaseTypeStringList$outboundSchema: z.ZodEnum<typeof CurrentReleaseTypeStringList>;
+/** @internal */
+export declare const CurrentReleaseDefaultStringList$inboundSchema: z.ZodType<CurrentReleaseDefaultStringList, unknown>;
+/** @internal */
+export type CurrentReleaseDefaultStringList$Outbound = {
+    type: string;
+    value: Array<string>;
+};
+/** @internal */
+export declare const CurrentReleaseDefaultStringList$outboundSchema: z.ZodType<CurrentReleaseDefaultStringList$Outbound, CurrentReleaseDefaultStringList>;
+export declare function currentReleaseDefaultStringListToJSON(currentReleaseDefaultStringList: CurrentReleaseDefaultStringList): string;
+export declare function currentReleaseDefaultStringListFromJSON(jsonString: string): SafeParseResult<CurrentReleaseDefaultStringList, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseTypeBoolean$inboundSchema: z.ZodEnum<typeof CurrentReleaseTypeBoolean>;
+/** @internal */
+export declare const CurrentReleaseTypeBoolean$outboundSchema: z.ZodEnum<typeof CurrentReleaseTypeBoolean>;
+/** @internal */
+export declare const CurrentReleaseDefaultBoolean$inboundSchema: z.ZodType<CurrentReleaseDefaultBoolean, unknown>;
+/** @internal */
+export type CurrentReleaseDefaultBoolean$Outbound = {
+    type: string;
+    value: boolean;
+};
+/** @internal */
+export declare const CurrentReleaseDefaultBoolean$outboundSchema: z.ZodType<CurrentReleaseDefaultBoolean$Outbound, CurrentReleaseDefaultBoolean>;
+export declare function currentReleaseDefaultBooleanToJSON(currentReleaseDefaultBoolean: CurrentReleaseDefaultBoolean): string;
+export declare function currentReleaseDefaultBooleanFromJSON(jsonString: string): SafeParseResult<CurrentReleaseDefaultBoolean, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseTypeNumber$inboundSchema: z.ZodEnum<typeof CurrentReleaseTypeNumber>;
+/** @internal */
+export declare const CurrentReleaseTypeNumber$outboundSchema: z.ZodEnum<typeof CurrentReleaseTypeNumber>;
+/** @internal */
+export declare const CurrentReleaseDefaultNumber$inboundSchema: z.ZodType<CurrentReleaseDefaultNumber, unknown>;
+/** @internal */
+export type CurrentReleaseDefaultNumber$Outbound = {
+    type: string;
+    value: string;
+};
+/** @internal */
+export declare const CurrentReleaseDefaultNumber$outboundSchema: z.ZodType<CurrentReleaseDefaultNumber$Outbound, CurrentReleaseDefaultNumber>;
+export declare function currentReleaseDefaultNumberToJSON(currentReleaseDefaultNumber: CurrentReleaseDefaultNumber): string;
+export declare function currentReleaseDefaultNumberFromJSON(jsonString: string): SafeParseResult<CurrentReleaseDefaultNumber, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseTypeString$inboundSchema: z.ZodEnum<typeof CurrentReleaseTypeString>;
+/** @internal */
+export declare const CurrentReleaseTypeString$outboundSchema: z.ZodEnum<typeof CurrentReleaseTypeString>;
+/** @internal */
+export declare const CurrentReleaseDefaultString$inboundSchema: z.ZodType<CurrentReleaseDefaultString, unknown>;
+/** @internal */
+export type CurrentReleaseDefaultString$Outbound = {
+    type: string;
+    value: string;
+};
+/** @internal */
+export declare const CurrentReleaseDefaultString$outboundSchema: z.ZodType<CurrentReleaseDefaultString$Outbound, CurrentReleaseDefaultString>;
+export declare function currentReleaseDefaultStringToJSON(currentReleaseDefaultString: CurrentReleaseDefaultString): string;
+export declare function currentReleaseDefaultStringFromJSON(jsonString: string): SafeParseResult<CurrentReleaseDefaultString, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseDefaultUnion$inboundSchema: z.ZodType<CurrentReleaseDefaultUnion, unknown>;
+/** @internal */
+export type CurrentReleaseDefaultUnion$Outbound = CurrentReleaseDefaultString$Outbound | CurrentReleaseDefaultNumber$Outbound | CurrentReleaseDefaultBoolean$Outbound | CurrentReleaseDefaultStringList$Outbound | string;
+/** @internal */
+export declare const CurrentReleaseDefaultUnion$outboundSchema: z.ZodType<CurrentReleaseDefaultUnion$Outbound, CurrentReleaseDefaultUnion>;
+export declare function currentReleaseDefaultUnionToJSON(currentReleaseDefaultUnion: CurrentReleaseDefaultUnion): string;
+export declare function currentReleaseDefaultUnionFromJSON(jsonString: string): SafeParseResult<CurrentReleaseDefaultUnion, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseTypeEnvEnum$inboundSchema: z.ZodEnum<typeof CurrentReleaseTypeEnvEnum>;
+/** @internal */
+export declare const CurrentReleaseTypeEnvEnum$outboundSchema: z.ZodEnum<typeof CurrentReleaseTypeEnvEnum>;
+/** @internal */
+export declare const CurrentReleaseTypeUnion$inboundSchema: z.ZodType<CurrentReleaseTypeUnion, unknown>;
+/** @internal */
+export type CurrentReleaseTypeUnion$Outbound = string | string;
+/** @internal */
+export declare const CurrentReleaseTypeUnion$outboundSchema: z.ZodType<CurrentReleaseTypeUnion$Outbound, CurrentReleaseTypeUnion>;
+export declare function currentReleaseTypeUnionToJSON(currentReleaseTypeUnion: CurrentReleaseTypeUnion): string;
+export declare function currentReleaseTypeUnionFromJSON(jsonString: string): SafeParseResult<CurrentReleaseTypeUnion, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseEnv$inboundSchema: z.ZodType<CurrentReleaseEnv, unknown>;
+/** @internal */
+export type CurrentReleaseEnv$Outbound = {
+    name: string;
+    targetResources?: Array<string> | null | undefined;
+    type?: string | string | null | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseEnv$outboundSchema: z.ZodType<CurrentReleaseEnv$Outbound, CurrentReleaseEnv>;
+export declare function currentReleaseEnvToJSON(currentReleaseEnv: CurrentReleaseEnv): string;
+export declare function currentReleaseEnvFromJSON(jsonString: string): SafeParseResult<CurrentReleaseEnv, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseGenerate$inboundSchema: z.ZodType<CurrentReleaseGenerate, unknown>;
+/** @internal */
+export type CurrentReleaseGenerate$Outbound = {
+    length: number;
+};
+/** @internal */
+export declare const CurrentReleaseGenerate$outboundSchema: z.ZodType<CurrentReleaseGenerate$Outbound, CurrentReleaseGenerate>;
+export declare function currentReleaseGenerateToJSON(currentReleaseGenerate: CurrentReleaseGenerate): string;
+export declare function currentReleaseGenerateFromJSON(jsonString: string): SafeParseResult<CurrentReleaseGenerate, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseGenerateUnion$inboundSchema: z.ZodType<CurrentReleaseGenerateUnion, unknown>;
+/** @internal */
+export type CurrentReleaseGenerateUnion$Outbound = CurrentReleaseGenerate$Outbound | string;
+/** @internal */
+export declare const CurrentReleaseGenerateUnion$outboundSchema: z.ZodType<CurrentReleaseGenerateUnion$Outbound, CurrentReleaseGenerateUnion>;
+export declare function currentReleaseGenerateUnionToJSON(currentReleaseGenerateUnion: CurrentReleaseGenerateUnion): string;
+export declare function currentReleaseGenerateUnionFromJSON(jsonString: string): SafeParseResult<CurrentReleaseGenerateUnion, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseKind$inboundSchema: z.ZodEnum<typeof CurrentReleaseKind>;
+/** @internal */
+export declare const CurrentReleaseKind$outboundSchema: z.ZodEnum<typeof CurrentReleaseKind>;
+/** @internal */
+export declare const CurrentReleasePlatform$inboundSchema: z.ZodEnum<typeof CurrentReleasePlatform>;
+/** @internal */
+export declare const CurrentReleasePlatform$outboundSchema: z.ZodEnum<typeof CurrentReleasePlatform>;
+/** @internal */
+export declare const CurrentReleaseProvidedBy$inboundSchema: z.ZodEnum<typeof CurrentReleaseProvidedBy>;
+/** @internal */
+export declare const CurrentReleaseProvidedBy$outboundSchema: z.ZodEnum<typeof CurrentReleaseProvidedBy>;
+/** @internal */
+export declare const CurrentReleaseValidation$inboundSchema: z.ZodType<CurrentReleaseValidation, unknown>;
+/** @internal */
+export type CurrentReleaseValidation$Outbound = {
+    format?: string | null | undefined;
+    max?: string | null | undefined;
+    maxItems?: number | null | undefined;
+    maxLength?: number | null | undefined;
+    min?: string | null | undefined;
+    minItems?: number | null | undefined;
+    minLength?: number | null | undefined;
+    pattern?: string | null | undefined;
+    values?: Array<string> | null | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseValidation$outboundSchema: z.ZodType<CurrentReleaseValidation$Outbound, CurrentReleaseValidation>;
+export declare function currentReleaseValidationToJSON(currentReleaseValidation: CurrentReleaseValidation): string;
+export declare function currentReleaseValidationFromJSON(jsonString: string): SafeParseResult<CurrentReleaseValidation, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseValidationUnion$inboundSchema: z.ZodType<CurrentReleaseValidationUnion, unknown>;
+/** @internal */
+export type CurrentReleaseValidationUnion$Outbound = CurrentReleaseValidation$Outbound | string;
+/** @internal */
+export declare const CurrentReleaseValidationUnion$outboundSchema: z.ZodType<CurrentReleaseValidationUnion$Outbound, CurrentReleaseValidationUnion>;
+export declare function currentReleaseValidationUnionToJSON(currentReleaseValidationUnion: CurrentReleaseValidationUnion): string;
+export declare function currentReleaseValidationUnionFromJSON(jsonString: string): SafeParseResult<CurrentReleaseValidationUnion, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseInput$inboundSchema: z.ZodType<CurrentReleaseInput, unknown>;
+/** @internal */
+export type CurrentReleaseInput$Outbound = {
+    default?: CurrentReleaseDefaultString$Outbound | CurrentReleaseDefaultNumber$Outbound | CurrentReleaseDefaultBoolean$Outbound | CurrentReleaseDefaultStringList$Outbound | string | null | undefined;
+    description: string;
+    env?: Array<CurrentReleaseEnv$Outbound> | undefined;
+    generate?: CurrentReleaseGenerate$Outbound | string | null | undefined;
+    id: string;
+    kind: string;
+    label: string;
+    placeholder?: string | null | undefined;
+    platforms?: Array<string> | null | undefined;
+    providedBy: Array<string>;
+    required: boolean;
+    validation?: CurrentReleaseValidation$Outbound | string | null | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseInput$outboundSchema: z.ZodType<CurrentReleaseInput$Outbound, CurrentReleaseInput>;
+export declare function currentReleaseInputToJSON(currentReleaseInput: CurrentReleaseInput): string;
+export declare function currentReleaseInputFromJSON(jsonString: string): SafeParseResult<CurrentReleaseInput, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseCustomDecision$inboundSchema: z.ZodEnum<typeof CurrentReleaseCustomDecision>;
+/** @internal */
+export declare const CurrentReleaseCustomDecision$outboundSchema: z.ZodEnum<typeof CurrentReleaseCustomDecision>;
+/** @internal */
+export declare const CurrentReleaseApprovalCustom$inboundSchema: z.ZodType<CurrentReleaseApprovalCustom, unknown>;
+/** @internal */
+export type CurrentReleaseApprovalCustom$Outbound = {
+    decision: string;
+    maxRisk?: string | null | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseApprovalCustom$outboundSchema: z.ZodType<CurrentReleaseApprovalCustom$Outbound, CurrentReleaseApprovalCustom>;
+export declare function currentReleaseApprovalCustomToJSON(currentReleaseApprovalCustom: CurrentReleaseApprovalCustom): string;
+export declare function currentReleaseApprovalCustomFromJSON(jsonString: string): SafeParseResult<CurrentReleaseApprovalCustom, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseApprovalCustomEnum$inboundSchema: z.ZodEnum<typeof CurrentReleaseApprovalCustomEnum>;
+/** @internal */
+export declare const CurrentReleaseApprovalCustomEnum$outboundSchema: z.ZodEnum<typeof CurrentReleaseApprovalCustomEnum>;
+/** @internal */
+export declare const CurrentReleaseCustomApprovalUnion$inboundSchema: z.ZodType<CurrentReleaseCustomApprovalUnion, unknown>;
+/** @internal */
+export type CurrentReleaseCustomApprovalUnion$Outbound = CurrentReleaseApprovalCustom$Outbound | string;
+/** @internal */
+export declare const CurrentReleaseCustomApprovalUnion$outboundSchema: z.ZodType<CurrentReleaseCustomApprovalUnion$Outbound, CurrentReleaseCustomApprovalUnion>;
+export declare function currentReleaseCustomApprovalUnionToJSON(currentReleaseCustomApprovalUnion: CurrentReleaseCustomApprovalUnion): string;
+export declare function currentReleaseCustomApprovalUnionFromJSON(jsonString: string): SafeParseResult<CurrentReleaseCustomApprovalUnion, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseSettingsCustom3$inboundSchema: z.ZodType<CurrentReleaseSettingsCustom3, unknown>;
+/** @internal */
+export type CurrentReleaseSettingsCustom3$Outbound = {
+    env: string;
+};
+/** @internal */
+export declare const CurrentReleaseSettingsCustom3$outboundSchema: z.ZodType<CurrentReleaseSettingsCustom3$Outbound, CurrentReleaseSettingsCustom3>;
+export declare function currentReleaseSettingsCustom3ToJSON(currentReleaseSettingsCustom3: CurrentReleaseSettingsCustom3): string;
+export declare function currentReleaseSettingsCustom3FromJSON(jsonString: string): SafeParseResult<CurrentReleaseSettingsCustom3, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseSettingsCustom2$inboundSchema: z.ZodType<CurrentReleaseSettingsCustom2, unknown>;
+/** @internal */
+export type CurrentReleaseSettingsCustom2$Outbound = {
+    resources: Array<string>;
+};
+/** @internal */
+export declare const CurrentReleaseSettingsCustom2$outboundSchema: z.ZodType<CurrentReleaseSettingsCustom2$Outbound, CurrentReleaseSettingsCustom2>;
+export declare function currentReleaseSettingsCustom2ToJSON(currentReleaseSettingsCustom2: CurrentReleaseSettingsCustom2): string;
+export declare function currentReleaseSettingsCustom2FromJSON(jsonString: string): SafeParseResult<CurrentReleaseSettingsCustom2, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseSettingsCustom1$inboundSchema: z.ZodType<CurrentReleaseSettingsCustom1, unknown>;
+/** @internal */
+export type CurrentReleaseSettingsCustom1$Outbound = {
+    input: string;
+};
+/** @internal */
+export declare const CurrentReleaseSettingsCustom1$outboundSchema: z.ZodType<CurrentReleaseSettingsCustom1$Outbound, CurrentReleaseSettingsCustom1>;
+export declare function currentReleaseSettingsCustom1ToJSON(currentReleaseSettingsCustom1: CurrentReleaseSettingsCustom1): string;
+export declare function currentReleaseSettingsCustom1FromJSON(jsonString: string): SafeParseResult<CurrentReleaseSettingsCustom1, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseCustomSettingsUnion$inboundSchema: z.ZodType<CurrentReleaseCustomSettingsUnion, unknown>;
+/** @internal */
+export type CurrentReleaseCustomSettingsUnion$Outbound = CurrentReleaseSettingsCustom1$Outbound | CurrentReleaseSettingsCustom2$Outbound | CurrentReleaseSettingsCustom3$Outbound | string;
+/** @internal */
+export declare const CurrentReleaseCustomSettingsUnion$outboundSchema: z.ZodType<CurrentReleaseCustomSettingsUnion$Outbound, CurrentReleaseCustomSettingsUnion>;
+export declare function currentReleaseCustomSettingsUnionToJSON(currentReleaseCustomSettingsUnion: CurrentReleaseCustomSettingsUnion): string;
+export declare function currentReleaseCustomSettingsUnionFromJSON(jsonString: string): SafeParseResult<CurrentReleaseCustomSettingsUnion, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseCustom$inboundSchema: z.ZodType<CurrentReleaseCustom, unknown>;
+/** @internal */
+export type CurrentReleaseCustom$Outbound = {
+    approval?: {
+        [k: string]: CurrentReleaseApprovalCustom$Outbound | string;
+    } | undefined;
+    settings?: {
+        [k: string]: CurrentReleaseSettingsCustom1$Outbound | CurrentReleaseSettingsCustom2$Outbound | CurrentReleaseSettingsCustom3$Outbound | string;
+    } | undefined;
+    name: string;
+    version: string;
+};
+/** @internal */
+export declare const CurrentReleaseCustom$outboundSchema: z.ZodType<CurrentReleaseCustom$Outbound, CurrentReleaseCustom>;
+export declare function currentReleaseCustomToJSON(currentReleaseCustom: CurrentReleaseCustom): string;
+export declare function currentReleaseCustomFromJSON(jsonString: string): SafeParseResult<CurrentReleaseCustom, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleasePluginsDecision$inboundSchema: z.ZodEnum<typeof CurrentReleasePluginsDecision>;
+/** @internal */
+export declare const CurrentReleasePluginsDecision$outboundSchema: z.ZodEnum<typeof CurrentReleasePluginsDecision>;
+/** @internal */
+export declare const CurrentReleaseApprovalPlugins$inboundSchema: z.ZodType<CurrentReleaseApprovalPlugins, unknown>;
+/** @internal */
+export type CurrentReleaseApprovalPlugins$Outbound = {
+    decision: string;
+    maxRisk?: string | null | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseApprovalPlugins$outboundSchema: z.ZodType<CurrentReleaseApprovalPlugins$Outbound, CurrentReleaseApprovalPlugins>;
+export declare function currentReleaseApprovalPluginsToJSON(currentReleaseApprovalPlugins: CurrentReleaseApprovalPlugins): string;
+export declare function currentReleaseApprovalPluginsFromJSON(jsonString: string): SafeParseResult<CurrentReleaseApprovalPlugins, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseApprovalPluginsEnum$inboundSchema: z.ZodEnum<typeof CurrentReleaseApprovalPluginsEnum>;
+/** @internal */
+export declare const CurrentReleaseApprovalPluginsEnum$outboundSchema: z.ZodEnum<typeof CurrentReleaseApprovalPluginsEnum>;
+/** @internal */
+export declare const CurrentReleasePluginsApprovalUnion$inboundSchema: z.ZodType<CurrentReleasePluginsApprovalUnion, unknown>;
+/** @internal */
+export type CurrentReleasePluginsApprovalUnion$Outbound = CurrentReleaseApprovalPlugins$Outbound | string;
+/** @internal */
+export declare const CurrentReleasePluginsApprovalUnion$outboundSchema: z.ZodType<CurrentReleasePluginsApprovalUnion$Outbound, CurrentReleasePluginsApprovalUnion>;
+export declare function currentReleasePluginsApprovalUnionToJSON(currentReleasePluginsApprovalUnion: CurrentReleasePluginsApprovalUnion): string;
+export declare function currentReleasePluginsApprovalUnionFromJSON(jsonString: string): SafeParseResult<CurrentReleasePluginsApprovalUnion, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseSettingsPlugins3$inboundSchema: z.ZodType<CurrentReleaseSettingsPlugins3, unknown>;
+/** @internal */
+export type CurrentReleaseSettingsPlugins3$Outbound = {
+    env: string;
+};
+/** @internal */
+export declare const CurrentReleaseSettingsPlugins3$outboundSchema: z.ZodType<CurrentReleaseSettingsPlugins3$Outbound, CurrentReleaseSettingsPlugins3>;
+export declare function currentReleaseSettingsPlugins3ToJSON(currentReleaseSettingsPlugins3: CurrentReleaseSettingsPlugins3): string;
+export declare function currentReleaseSettingsPlugins3FromJSON(jsonString: string): SafeParseResult<CurrentReleaseSettingsPlugins3, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseSettingsPlugins2$inboundSchema: z.ZodType<CurrentReleaseSettingsPlugins2, unknown>;
+/** @internal */
+export type CurrentReleaseSettingsPlugins2$Outbound = {
+    resources: Array<string>;
+};
+/** @internal */
+export declare const CurrentReleaseSettingsPlugins2$outboundSchema: z.ZodType<CurrentReleaseSettingsPlugins2$Outbound, CurrentReleaseSettingsPlugins2>;
+export declare function currentReleaseSettingsPlugins2ToJSON(currentReleaseSettingsPlugins2: CurrentReleaseSettingsPlugins2): string;
+export declare function currentReleaseSettingsPlugins2FromJSON(jsonString: string): SafeParseResult<CurrentReleaseSettingsPlugins2, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseSettingsPlugins1$inboundSchema: z.ZodType<CurrentReleaseSettingsPlugins1, unknown>;
+/** @internal */
+export type CurrentReleaseSettingsPlugins1$Outbound = {
+    input: string;
+};
+/** @internal */
+export declare const CurrentReleaseSettingsPlugins1$outboundSchema: z.ZodType<CurrentReleaseSettingsPlugins1$Outbound, CurrentReleaseSettingsPlugins1>;
+export declare function currentReleaseSettingsPlugins1ToJSON(currentReleaseSettingsPlugins1: CurrentReleaseSettingsPlugins1): string;
+export declare function currentReleaseSettingsPlugins1FromJSON(jsonString: string): SafeParseResult<CurrentReleaseSettingsPlugins1, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleasePluginsSettingsUnion$inboundSchema: z.ZodType<CurrentReleasePluginsSettingsUnion, unknown>;
+/** @internal */
+export type CurrentReleasePluginsSettingsUnion$Outbound = CurrentReleaseSettingsPlugins1$Outbound | CurrentReleaseSettingsPlugins2$Outbound | CurrentReleaseSettingsPlugins3$Outbound | string;
+/** @internal */
+export declare const CurrentReleasePluginsSettingsUnion$outboundSchema: z.ZodType<CurrentReleasePluginsSettingsUnion$Outbound, CurrentReleasePluginsSettingsUnion>;
+export declare function currentReleasePluginsSettingsUnionToJSON(currentReleasePluginsSettingsUnion: CurrentReleasePluginsSettingsUnion): string;
+export declare function currentReleasePluginsSettingsUnionFromJSON(jsonString: string): SafeParseResult<CurrentReleasePluginsSettingsUnion, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleasePlugins$inboundSchema: z.ZodType<CurrentReleasePlugins, unknown>;
+/** @internal */
+export type CurrentReleasePlugins$Outbound = {
+    approval?: {
+        [k: string]: CurrentReleaseApprovalPlugins$Outbound | string;
+    } | undefined;
+    settings?: {
+        [k: string]: CurrentReleaseSettingsPlugins1$Outbound | CurrentReleaseSettingsPlugins2$Outbound | CurrentReleaseSettingsPlugins3$Outbound | string;
+    } | undefined;
+};
+/** @internal */
+export declare const CurrentReleasePlugins$outboundSchema: z.ZodType<CurrentReleasePlugins$Outbound, CurrentReleasePlugins>;
+export declare function currentReleasePluginsToJSON(currentReleasePlugins: CurrentReleasePlugins): string;
+export declare function currentReleasePluginsFromJSON(jsonString: string): SafeParseResult<CurrentReleasePlugins, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseOperations$inboundSchema: z.ZodType<CurrentReleaseOperations, unknown>;
+/** @internal */
+export type CurrentReleaseOperations$Outbound = {
+    custom?: Array<CurrentReleaseCustom$Outbound> | undefined;
+    plugins?: {
+        [k: string]: CurrentReleasePlugins$Outbound;
+    } | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseOperations$outboundSchema: z.ZodType<CurrentReleaseOperations$Outbound, CurrentReleaseOperations>;
+export declare function currentReleaseOperationsToJSON(currentReleaseOperations: CurrentReleaseOperations): string;
+export declare function currentReleaseOperationsFromJSON(jsonString: string): SafeParseResult<CurrentReleaseOperations, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseOperationsUnion$inboundSchema: z.ZodType<CurrentReleaseOperationsUnion, unknown>;
+/** @internal */
+export type CurrentReleaseOperationsUnion$Outbound = CurrentReleaseOperations$Outbound | string;
+/** @internal */
+export declare const CurrentReleaseOperationsUnion$outboundSchema: z.ZodType<CurrentReleaseOperationsUnion$Outbound, CurrentReleaseOperationsUnion>;
+export declare function currentReleaseOperationsUnionToJSON(currentReleaseOperationsUnion: CurrentReleaseOperationsUnion): string;
+export declare function currentReleaseOperationsUnionFromJSON(jsonString: string): SafeParseResult<CurrentReleaseOperationsUnion, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseManagementEnum$inboundSchema: z.ZodEnum<typeof CurrentReleaseManagementEnum>;
+/** @internal */
+export declare const CurrentReleaseManagementEnum$outboundSchema: z.ZodEnum<typeof CurrentReleaseManagementEnum>;
+/** @internal */
+export declare const CurrentReleaseOverrideAwResource$inboundSchema: z.ZodType<CurrentReleaseOverrideAwResource, unknown>;
+/** @internal */
+export type CurrentReleaseOverrideAwResource$Outbound = {
+    condition?: {
+        [k: string]: {
+            [k: string]: string;
+        };
+    } | null | undefined;
+    notResources?: Array<string> | undefined;
+    resources: Array<string>;
+};
+/** @internal */
+export declare const CurrentReleaseOverrideAwResource$outboundSchema: z.ZodType<CurrentReleaseOverrideAwResource$Outbound, CurrentReleaseOverrideAwResource>;
+export declare function currentReleaseOverrideAwResourceToJSON(currentReleaseOverrideAwResource: CurrentReleaseOverrideAwResource): string;
+export declare function currentReleaseOverrideAwResourceFromJSON(jsonString: string): SafeParseResult<CurrentReleaseOverrideAwResource, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseOverrideAwStack$inboundSchema: z.ZodType<CurrentReleaseOverrideAwStack, unknown>;
+/** @internal */
+export type CurrentReleaseOverrideAwStack$Outbound = {
+    condition?: {
+        [k: string]: {
+            [k: string]: string;
+        };
+    } | null | undefined;
+    notResources?: Array<string> | undefined;
+    resources: Array<string>;
+};
+/** @internal */
+export declare const CurrentReleaseOverrideAwStack$outboundSchema: z.ZodType<CurrentReleaseOverrideAwStack$Outbound, CurrentReleaseOverrideAwStack>;
+export declare function currentReleaseOverrideAwStackToJSON(currentReleaseOverrideAwStack: CurrentReleaseOverrideAwStack): string;
+export declare function currentReleaseOverrideAwStackFromJSON(jsonString: string): SafeParseResult<CurrentReleaseOverrideAwStack, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseOverrideAwBinding$inboundSchema: z.ZodType<CurrentReleaseOverrideAwBinding, unknown>;
+/** @internal */
+export type CurrentReleaseOverrideAwBinding$Outbound = {
+    resource?: CurrentReleaseOverrideAwResource$Outbound | undefined;
+    stack?: CurrentReleaseOverrideAwStack$Outbound | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseOverrideAwBinding$outboundSchema: z.ZodType<CurrentReleaseOverrideAwBinding$Outbound, CurrentReleaseOverrideAwBinding>;
+export declare function currentReleaseOverrideAwBindingToJSON(currentReleaseOverrideAwBinding: CurrentReleaseOverrideAwBinding): string;
+export declare function currentReleaseOverrideAwBindingFromJSON(jsonString: string): SafeParseResult<CurrentReleaseOverrideAwBinding, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseOverrideEffect$inboundSchema: z.ZodEnum<typeof CurrentReleaseOverrideEffect>;
+/** @internal */
+export declare const CurrentReleaseOverrideEffect$outboundSchema: z.ZodEnum<typeof CurrentReleaseOverrideEffect>;
+/** @internal */
+export declare const CurrentReleaseOverrideAwGrant$inboundSchema: z.ZodType<CurrentReleaseOverrideAwGrant, unknown>;
+/** @internal */
+export type CurrentReleaseOverrideAwGrant$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 CurrentReleaseOverrideAwGrant$outboundSchema: z.ZodType<CurrentReleaseOverrideAwGrant$Outbound, CurrentReleaseOverrideAwGrant>;
+export declare function currentReleaseOverrideAwGrantToJSON(currentReleaseOverrideAwGrant: CurrentReleaseOverrideAwGrant): string;
+export declare function currentReleaseOverrideAwGrantFromJSON(jsonString: string): SafeParseResult<CurrentReleaseOverrideAwGrant, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseOverrideAw$inboundSchema: z.ZodType<CurrentReleaseOverrideAw, unknown>;
+/** @internal */
+export type CurrentReleaseOverrideAw$Outbound = {
+    binding: CurrentReleaseOverrideAwBinding$Outbound;
+    description?: string | null | undefined;
+    effect?: string | undefined;
+    grant: CurrentReleaseOverrideAwGrant$Outbound;
+    label?: string | null | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseOverrideAw$outboundSchema: z.ZodType<CurrentReleaseOverrideAw$Outbound, CurrentReleaseOverrideAw>;
+export declare function currentReleaseOverrideAwToJSON(currentReleaseOverrideAw: CurrentReleaseOverrideAw): string;
+export declare function currentReleaseOverrideAwFromJSON(jsonString: string): SafeParseResult<CurrentReleaseOverrideAw, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseOverrideAzureResource$inboundSchema: z.ZodType<CurrentReleaseOverrideAzureResource, unknown>;
+/** @internal */
+export type CurrentReleaseOverrideAzureResource$Outbound = {
+    scope: string;
+};
+/** @internal */
+export declare const CurrentReleaseOverrideAzureResource$outboundSchema: z.ZodType<CurrentReleaseOverrideAzureResource$Outbound, CurrentReleaseOverrideAzureResource>;
+export declare function currentReleaseOverrideAzureResourceToJSON(currentReleaseOverrideAzureResource: CurrentReleaseOverrideAzureResource): string;
+export declare function currentReleaseOverrideAzureResourceFromJSON(jsonString: string): SafeParseResult<CurrentReleaseOverrideAzureResource, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseOverrideAzureStack$inboundSchema: z.ZodType<CurrentReleaseOverrideAzureStack, unknown>;
+/** @internal */
+export type CurrentReleaseOverrideAzureStack$Outbound = {
+    scope: string;
+};
+/** @internal */
+export declare const CurrentReleaseOverrideAzureStack$outboundSchema: z.ZodType<CurrentReleaseOverrideAzureStack$Outbound, CurrentReleaseOverrideAzureStack>;
+export declare function currentReleaseOverrideAzureStackToJSON(currentReleaseOverrideAzureStack: CurrentReleaseOverrideAzureStack): string;
+export declare function currentReleaseOverrideAzureStackFromJSON(jsonString: string): SafeParseResult<CurrentReleaseOverrideAzureStack, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseOverrideAzureBinding$inboundSchema: z.ZodType<CurrentReleaseOverrideAzureBinding, unknown>;
+/** @internal */
+export type CurrentReleaseOverrideAzureBinding$Outbound = {
+    resource?: CurrentReleaseOverrideAzureResource$Outbound | undefined;
+    stack?: CurrentReleaseOverrideAzureStack$Outbound | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseOverrideAzureBinding$outboundSchema: z.ZodType<CurrentReleaseOverrideAzureBinding$Outbound, CurrentReleaseOverrideAzureBinding>;
+export declare function currentReleaseOverrideAzureBindingToJSON(currentReleaseOverrideAzureBinding: CurrentReleaseOverrideAzureBinding): string;
+export declare function currentReleaseOverrideAzureBindingFromJSON(jsonString: string): SafeParseResult<CurrentReleaseOverrideAzureBinding, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseOverrideAzureGrant$inboundSchema: z.ZodType<CurrentReleaseOverrideAzureGrant, unknown>;
+/** @internal */
+export type CurrentReleaseOverrideAzureGrant$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 CurrentReleaseOverrideAzureGrant$outboundSchema: z.ZodType<CurrentReleaseOverrideAzureGrant$Outbound, CurrentReleaseOverrideAzureGrant>;
+export declare function currentReleaseOverrideAzureGrantToJSON(currentReleaseOverrideAzureGrant: CurrentReleaseOverrideAzureGrant): string;
+export declare function currentReleaseOverrideAzureGrantFromJSON(jsonString: string): SafeParseResult<CurrentReleaseOverrideAzureGrant, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseOverrideAzure$inboundSchema: z.ZodType<CurrentReleaseOverrideAzure, unknown>;
+/** @internal */
+export type CurrentReleaseOverrideAzure$Outbound = {
+    binding: CurrentReleaseOverrideAzureBinding$Outbound;
+    description?: string | null | undefined;
+    grant: CurrentReleaseOverrideAzureGrant$Outbound;
+    label?: string | null | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseOverrideAzure$outboundSchema: z.ZodType<CurrentReleaseOverrideAzure$Outbound, CurrentReleaseOverrideAzure>;
+export declare function currentReleaseOverrideAzureToJSON(currentReleaseOverrideAzure: CurrentReleaseOverrideAzure): string;
+export declare function currentReleaseOverrideAzureFromJSON(jsonString: string): SafeParseResult<CurrentReleaseOverrideAzure, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseOverrideConditionResource$inboundSchema: z.ZodType<CurrentReleaseOverrideConditionResource, unknown>;
+/** @internal */
+export type CurrentReleaseOverrideConditionResource$Outbound = {
+    expression: string;
+    title: string;
+};
+/** @internal */
+export declare const CurrentReleaseOverrideConditionResource$outboundSchema: z.ZodType<CurrentReleaseOverrideConditionResource$Outbound, CurrentReleaseOverrideConditionResource>;
+export declare function currentReleaseOverrideConditionResourceToJSON(currentReleaseOverrideConditionResource: CurrentReleaseOverrideConditionResource): string;
+export declare function currentReleaseOverrideConditionResourceFromJSON(jsonString: string): SafeParseResult<CurrentReleaseOverrideConditionResource, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseOverrideResourceConditionUnion$inboundSchema: z.ZodType<CurrentReleaseOverrideResourceConditionUnion, unknown>;
+/** @internal */
+export type CurrentReleaseOverrideResourceConditionUnion$Outbound = CurrentReleaseOverrideConditionResource$Outbound | string;
+/** @internal */
+export declare const CurrentReleaseOverrideResourceConditionUnion$outboundSchema: z.ZodType<CurrentReleaseOverrideResourceConditionUnion$Outbound, CurrentReleaseOverrideResourceConditionUnion>;
+export declare function currentReleaseOverrideResourceConditionUnionToJSON(currentReleaseOverrideResourceConditionUnion: CurrentReleaseOverrideResourceConditionUnion): string;
+export declare function currentReleaseOverrideResourceConditionUnionFromJSON(jsonString: string): SafeParseResult<CurrentReleaseOverrideResourceConditionUnion, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseOverrideGcpResource$inboundSchema: z.ZodType<CurrentReleaseOverrideGcpResource, unknown>;
+/** @internal */
+export type CurrentReleaseOverrideGcpResource$Outbound = {
+    condition?: CurrentReleaseOverrideConditionResource$Outbound | string | null | undefined;
+    scope: string;
+};
+/** @internal */
+export declare const CurrentReleaseOverrideGcpResource$outboundSchema: z.ZodType<CurrentReleaseOverrideGcpResource$Outbound, CurrentReleaseOverrideGcpResource>;
+export declare function currentReleaseOverrideGcpResourceToJSON(currentReleaseOverrideGcpResource: CurrentReleaseOverrideGcpResource): string;
+export declare function currentReleaseOverrideGcpResourceFromJSON(jsonString: string): SafeParseResult<CurrentReleaseOverrideGcpResource, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseOverrideCondition$inboundSchema: z.ZodType<CurrentReleaseOverrideCondition, unknown>;
+/** @internal */
+export type CurrentReleaseOverrideCondition$Outbound = {
+    expression: string;
+    title: string;
+};
+/** @internal */
+export declare const CurrentReleaseOverrideCondition$outboundSchema: z.ZodType<CurrentReleaseOverrideCondition$Outbound, CurrentReleaseOverrideCondition>;
+export declare function currentReleaseOverrideConditionToJSON(currentReleaseOverrideCondition: CurrentReleaseOverrideCondition): string;
+export declare function currentReleaseOverrideConditionFromJSON(jsonString: string): SafeParseResult<CurrentReleaseOverrideCondition, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseOverrideConditionUnion$inboundSchema: z.ZodType<CurrentReleaseOverrideConditionUnion, unknown>;
+/** @internal */
+export type CurrentReleaseOverrideConditionUnion$Outbound = CurrentReleaseOverrideCondition$Outbound | string;
+/** @internal */
+export declare const CurrentReleaseOverrideConditionUnion$outboundSchema: z.ZodType<CurrentReleaseOverrideConditionUnion$Outbound, CurrentReleaseOverrideConditionUnion>;
+export declare function currentReleaseOverrideConditionUnionToJSON(currentReleaseOverrideConditionUnion: CurrentReleaseOverrideConditionUnion): string;
+export declare function currentReleaseOverrideConditionUnionFromJSON(jsonString: string): SafeParseResult<CurrentReleaseOverrideConditionUnion, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseOverrideGcpStack$inboundSchema: z.ZodType<CurrentReleaseOverrideGcpStack, unknown>;
+/** @internal */
+export type CurrentReleaseOverrideGcpStack$Outbound = {
+    condition?: CurrentReleaseOverrideCondition$Outbound | string | null | undefined;
+    scope: string;
+};
+/** @internal */
+export declare const CurrentReleaseOverrideGcpStack$outboundSchema: z.ZodType<CurrentReleaseOverrideGcpStack$Outbound, CurrentReleaseOverrideGcpStack>;
+export declare function currentReleaseOverrideGcpStackToJSON(currentReleaseOverrideGcpStack: CurrentReleaseOverrideGcpStack): string;
+export declare function currentReleaseOverrideGcpStackFromJSON(jsonString: string): SafeParseResult<CurrentReleaseOverrideGcpStack, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseOverrideGcpBinding$inboundSchema: z.ZodType<CurrentReleaseOverrideGcpBinding, unknown>;
+/** @internal */
+export type CurrentReleaseOverrideGcpBinding$Outbound = {
+    resource?: CurrentReleaseOverrideGcpResource$Outbound | undefined;
+    stack?: CurrentReleaseOverrideGcpStack$Outbound | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseOverrideGcpBinding$outboundSchema: z.ZodType<CurrentReleaseOverrideGcpBinding$Outbound, CurrentReleaseOverrideGcpBinding>;
+export declare function currentReleaseOverrideGcpBindingToJSON(currentReleaseOverrideGcpBinding: CurrentReleaseOverrideGcpBinding): string;
+export declare function currentReleaseOverrideGcpBindingFromJSON(jsonString: string): SafeParseResult<CurrentReleaseOverrideGcpBinding, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseOverrideGcpGrant$inboundSchema: z.ZodType<CurrentReleaseOverrideGcpGrant, unknown>;
+/** @internal */
+export type CurrentReleaseOverrideGcpGrant$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 CurrentReleaseOverrideGcpGrant$outboundSchema: z.ZodType<CurrentReleaseOverrideGcpGrant$Outbound, CurrentReleaseOverrideGcpGrant>;
+export declare function currentReleaseOverrideGcpGrantToJSON(currentReleaseOverrideGcpGrant: CurrentReleaseOverrideGcpGrant): string;
+export declare function currentReleaseOverrideGcpGrantFromJSON(jsonString: string): SafeParseResult<CurrentReleaseOverrideGcpGrant, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseOverrideGcp$inboundSchema: z.ZodType<CurrentReleaseOverrideGcp, unknown>;
+/** @internal */
+export type CurrentReleaseOverrideGcp$Outbound = {
+    binding: CurrentReleaseOverrideGcpBinding$Outbound;
+    description?: string | null | undefined;
+    grant: CurrentReleaseOverrideGcpGrant$Outbound;
+    label?: string | null | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseOverrideGcp$outboundSchema: z.ZodType<CurrentReleaseOverrideGcp$Outbound, CurrentReleaseOverrideGcp>;
+export declare function currentReleaseOverrideGcpToJSON(currentReleaseOverrideGcp: CurrentReleaseOverrideGcp): string;
+export declare function currentReleaseOverrideGcpFromJSON(jsonString: string): SafeParseResult<CurrentReleaseOverrideGcp, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseOverridePlatforms$inboundSchema: z.ZodType<CurrentReleaseOverridePlatforms, unknown>;
+/** @internal */
+export type CurrentReleaseOverridePlatforms$Outbound = {
+    aws?: Array<CurrentReleaseOverrideAw$Outbound> | null | undefined;
+    azure?: Array<CurrentReleaseOverrideAzure$Outbound> | null | undefined;
+    gcp?: Array<CurrentReleaseOverrideGcp$Outbound> | null | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseOverridePlatforms$outboundSchema: z.ZodType<CurrentReleaseOverridePlatforms$Outbound, CurrentReleaseOverridePlatforms>;
+export declare function currentReleaseOverridePlatformsToJSON(currentReleaseOverridePlatforms: CurrentReleaseOverridePlatforms): string;
+export declare function currentReleaseOverridePlatformsFromJSON(jsonString: string): SafeParseResult<CurrentReleaseOverridePlatforms, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseOverride$inboundSchema: z.ZodType<CurrentReleaseOverride, unknown>;
+/** @internal */
+export type CurrentReleaseOverride$Outbound = {
+    description: string;
+    id: string;
+    platforms: CurrentReleaseOverridePlatforms$Outbound;
+};
+/** @internal */
+export declare const CurrentReleaseOverride$outboundSchema: z.ZodType<CurrentReleaseOverride$Outbound, CurrentReleaseOverride>;
+export declare function currentReleaseOverrideToJSON(currentReleaseOverride: CurrentReleaseOverride): string;
+export declare function currentReleaseOverrideFromJSON(jsonString: string): SafeParseResult<CurrentReleaseOverride, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseOverrideUnion$inboundSchema: z.ZodType<CurrentReleaseOverrideUnion, unknown>;
+/** @internal */
+export type CurrentReleaseOverrideUnion$Outbound = CurrentReleaseOverride$Outbound | string;
+/** @internal */
+export declare const CurrentReleaseOverrideUnion$outboundSchema: z.ZodType<CurrentReleaseOverrideUnion$Outbound, CurrentReleaseOverrideUnion>;
+export declare function currentReleaseOverrideUnionToJSON(currentReleaseOverrideUnion: CurrentReleaseOverrideUnion): string;
+export declare function currentReleaseOverrideUnionFromJSON(jsonString: string): SafeParseResult<CurrentReleaseOverrideUnion, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseManagement2$inboundSchema: z.ZodType<CurrentReleaseManagement2, unknown>;
+/** @internal */
+export type CurrentReleaseManagement2$Outbound = {
+    override: {
+        [k: string]: Array<CurrentReleaseOverride$Outbound | string>;
+    };
+};
+/** @internal */
+export declare const CurrentReleaseManagement2$outboundSchema: z.ZodType<CurrentReleaseManagement2$Outbound, CurrentReleaseManagement2>;
+export declare function currentReleaseManagement2ToJSON(currentReleaseManagement2: CurrentReleaseManagement2): string;
+export declare function currentReleaseManagement2FromJSON(jsonString: string): SafeParseResult<CurrentReleaseManagement2, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseExtendAwResource$inboundSchema: z.ZodType<CurrentReleaseExtendAwResource, unknown>;
+/** @internal */
+export type CurrentReleaseExtendAwResource$Outbound = {
+    condition?: {
+        [k: string]: {
+            [k: string]: string;
+        };
+    } | null | undefined;
+    notResources?: Array<string> | undefined;
+    resources: Array<string>;
+};
+/** @internal */
+export declare const CurrentReleaseExtendAwResource$outboundSchema: z.ZodType<CurrentReleaseExtendAwResource$Outbound, CurrentReleaseExtendAwResource>;
+export declare function currentReleaseExtendAwResourceToJSON(currentReleaseExtendAwResource: CurrentReleaseExtendAwResource): string;
+export declare function currentReleaseExtendAwResourceFromJSON(jsonString: string): SafeParseResult<CurrentReleaseExtendAwResource, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseExtendAwStack$inboundSchema: z.ZodType<CurrentReleaseExtendAwStack, unknown>;
+/** @internal */
+export type CurrentReleaseExtendAwStack$Outbound = {
+    condition?: {
+        [k: string]: {
+            [k: string]: string;
+        };
+    } | null | undefined;
+    notResources?: Array<string> | undefined;
+    resources: Array<string>;
+};
+/** @internal */
+export declare const CurrentReleaseExtendAwStack$outboundSchema: z.ZodType<CurrentReleaseExtendAwStack$Outbound, CurrentReleaseExtendAwStack>;
+export declare function currentReleaseExtendAwStackToJSON(currentReleaseExtendAwStack: CurrentReleaseExtendAwStack): string;
+export declare function currentReleaseExtendAwStackFromJSON(jsonString: string): SafeParseResult<CurrentReleaseExtendAwStack, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseExtendAwBinding$inboundSchema: z.ZodType<CurrentReleaseExtendAwBinding, unknown>;
+/** @internal */
+export type CurrentReleaseExtendAwBinding$Outbound = {
+    resource?: CurrentReleaseExtendAwResource$Outbound | undefined;
+    stack?: CurrentReleaseExtendAwStack$Outbound | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseExtendAwBinding$outboundSchema: z.ZodType<CurrentReleaseExtendAwBinding$Outbound, CurrentReleaseExtendAwBinding>;
+export declare function currentReleaseExtendAwBindingToJSON(currentReleaseExtendAwBinding: CurrentReleaseExtendAwBinding): string;
+export declare function currentReleaseExtendAwBindingFromJSON(jsonString: string): SafeParseResult<CurrentReleaseExtendAwBinding, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseExtendEffect$inboundSchema: z.ZodEnum<typeof CurrentReleaseExtendEffect>;
+/** @internal */
+export declare const CurrentReleaseExtendEffect$outboundSchema: z.ZodEnum<typeof CurrentReleaseExtendEffect>;
+/** @internal */
+export declare const CurrentReleaseExtendAwGrant$inboundSchema: z.ZodType<CurrentReleaseExtendAwGrant, unknown>;
+/** @internal */
+export type CurrentReleaseExtendAwGrant$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 CurrentReleaseExtendAwGrant$outboundSchema: z.ZodType<CurrentReleaseExtendAwGrant$Outbound, CurrentReleaseExtendAwGrant>;
+export declare function currentReleaseExtendAwGrantToJSON(currentReleaseExtendAwGrant: CurrentReleaseExtendAwGrant): string;
+export declare function currentReleaseExtendAwGrantFromJSON(jsonString: string): SafeParseResult<CurrentReleaseExtendAwGrant, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseExtendAw$inboundSchema: z.ZodType<CurrentReleaseExtendAw, unknown>;
+/** @internal */
+export type CurrentReleaseExtendAw$Outbound = {
+    binding: CurrentReleaseExtendAwBinding$Outbound;
+    description?: string | null | undefined;
+    effect?: string | undefined;
+    grant: CurrentReleaseExtendAwGrant$Outbound;
+    label?: string | null | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseExtendAw$outboundSchema: z.ZodType<CurrentReleaseExtendAw$Outbound, CurrentReleaseExtendAw>;
+export declare function currentReleaseExtendAwToJSON(currentReleaseExtendAw: CurrentReleaseExtendAw): string;
+export declare function currentReleaseExtendAwFromJSON(jsonString: string): SafeParseResult<CurrentReleaseExtendAw, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseExtendAzureResource$inboundSchema: z.ZodType<CurrentReleaseExtendAzureResource, unknown>;
+/** @internal */
+export type CurrentReleaseExtendAzureResource$Outbound = {
+    scope: string;
+};
+/** @internal */
+export declare const CurrentReleaseExtendAzureResource$outboundSchema: z.ZodType<CurrentReleaseExtendAzureResource$Outbound, CurrentReleaseExtendAzureResource>;
+export declare function currentReleaseExtendAzureResourceToJSON(currentReleaseExtendAzureResource: CurrentReleaseExtendAzureResource): string;
+export declare function currentReleaseExtendAzureResourceFromJSON(jsonString: string): SafeParseResult<CurrentReleaseExtendAzureResource, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseExtendAzureStack$inboundSchema: z.ZodType<CurrentReleaseExtendAzureStack, unknown>;
+/** @internal */
+export type CurrentReleaseExtendAzureStack$Outbound = {
+    scope: string;
+};
+/** @internal */
+export declare const CurrentReleaseExtendAzureStack$outboundSchema: z.ZodType<CurrentReleaseExtendAzureStack$Outbound, CurrentReleaseExtendAzureStack>;
+export declare function currentReleaseExtendAzureStackToJSON(currentReleaseExtendAzureStack: CurrentReleaseExtendAzureStack): string;
+export declare function currentReleaseExtendAzureStackFromJSON(jsonString: string): SafeParseResult<CurrentReleaseExtendAzureStack, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseExtendAzureBinding$inboundSchema: z.ZodType<CurrentReleaseExtendAzureBinding, unknown>;
+/** @internal */
+export type CurrentReleaseExtendAzureBinding$Outbound = {
+    resource?: CurrentReleaseExtendAzureResource$Outbound | undefined;
+    stack?: CurrentReleaseExtendAzureStack$Outbound | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseExtendAzureBinding$outboundSchema: z.ZodType<CurrentReleaseExtendAzureBinding$Outbound, CurrentReleaseExtendAzureBinding>;
+export declare function currentReleaseExtendAzureBindingToJSON(currentReleaseExtendAzureBinding: CurrentReleaseExtendAzureBinding): string;
+export declare function currentReleaseExtendAzureBindingFromJSON(jsonString: string): SafeParseResult<CurrentReleaseExtendAzureBinding, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseExtendAzureGrant$inboundSchema: z.ZodType<CurrentReleaseExtendAzureGrant, unknown>;
+/** @internal */
+export type CurrentReleaseExtendAzureGrant$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 CurrentReleaseExtendAzureGrant$outboundSchema: z.ZodType<CurrentReleaseExtendAzureGrant$Outbound, CurrentReleaseExtendAzureGrant>;
+export declare function currentReleaseExtendAzureGrantToJSON(currentReleaseExtendAzureGrant: CurrentReleaseExtendAzureGrant): string;
+export declare function currentReleaseExtendAzureGrantFromJSON(jsonString: string): SafeParseResult<CurrentReleaseExtendAzureGrant, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseExtendAzure$inboundSchema: z.ZodType<CurrentReleaseExtendAzure, unknown>;
+/** @internal */
+export type CurrentReleaseExtendAzure$Outbound = {
+    binding: CurrentReleaseExtendAzureBinding$Outbound;
+    description?: string | null | undefined;
+    grant: CurrentReleaseExtendAzureGrant$Outbound;
+    label?: string | null | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseExtendAzure$outboundSchema: z.ZodType<CurrentReleaseExtendAzure$Outbound, CurrentReleaseExtendAzure>;
+export declare function currentReleaseExtendAzureToJSON(currentReleaseExtendAzure: CurrentReleaseExtendAzure): string;
+export declare function currentReleaseExtendAzureFromJSON(jsonString: string): SafeParseResult<CurrentReleaseExtendAzure, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseExtendConditionResource$inboundSchema: z.ZodType<CurrentReleaseExtendConditionResource, unknown>;
+/** @internal */
+export type CurrentReleaseExtendConditionResource$Outbound = {
+    expression: string;
+    title: string;
+};
+/** @internal */
+export declare const CurrentReleaseExtendConditionResource$outboundSchema: z.ZodType<CurrentReleaseExtendConditionResource$Outbound, CurrentReleaseExtendConditionResource>;
+export declare function currentReleaseExtendConditionResourceToJSON(currentReleaseExtendConditionResource: CurrentReleaseExtendConditionResource): string;
+export declare function currentReleaseExtendConditionResourceFromJSON(jsonString: string): SafeParseResult<CurrentReleaseExtendConditionResource, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseExtendResourceConditionUnion$inboundSchema: z.ZodType<CurrentReleaseExtendResourceConditionUnion, unknown>;
+/** @internal */
+export type CurrentReleaseExtendResourceConditionUnion$Outbound = CurrentReleaseExtendConditionResource$Outbound | string;
+/** @internal */
+export declare const CurrentReleaseExtendResourceConditionUnion$outboundSchema: z.ZodType<CurrentReleaseExtendResourceConditionUnion$Outbound, CurrentReleaseExtendResourceConditionUnion>;
+export declare function currentReleaseExtendResourceConditionUnionToJSON(currentReleaseExtendResourceConditionUnion: CurrentReleaseExtendResourceConditionUnion): string;
+export declare function currentReleaseExtendResourceConditionUnionFromJSON(jsonString: string): SafeParseResult<CurrentReleaseExtendResourceConditionUnion, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseExtendGcpResource$inboundSchema: z.ZodType<CurrentReleaseExtendGcpResource, unknown>;
+/** @internal */
+export type CurrentReleaseExtendGcpResource$Outbound = {
+    condition?: CurrentReleaseExtendConditionResource$Outbound | string | null | undefined;
+    scope: string;
+};
+/** @internal */
+export declare const CurrentReleaseExtendGcpResource$outboundSchema: z.ZodType<CurrentReleaseExtendGcpResource$Outbound, CurrentReleaseExtendGcpResource>;
+export declare function currentReleaseExtendGcpResourceToJSON(currentReleaseExtendGcpResource: CurrentReleaseExtendGcpResource): string;
+export declare function currentReleaseExtendGcpResourceFromJSON(jsonString: string): SafeParseResult<CurrentReleaseExtendGcpResource, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseExtendCondition$inboundSchema: z.ZodType<CurrentReleaseExtendCondition, unknown>;
+/** @internal */
+export type CurrentReleaseExtendCondition$Outbound = {
+    expression: string;
+    title: string;
+};
+/** @internal */
+export declare const CurrentReleaseExtendCondition$outboundSchema: z.ZodType<CurrentReleaseExtendCondition$Outbound, CurrentReleaseExtendCondition>;
+export declare function currentReleaseExtendConditionToJSON(currentReleaseExtendCondition: CurrentReleaseExtendCondition): string;
+export declare function currentReleaseExtendConditionFromJSON(jsonString: string): SafeParseResult<CurrentReleaseExtendCondition, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseExtendConditionUnion$inboundSchema: z.ZodType<CurrentReleaseExtendConditionUnion, unknown>;
+/** @internal */
+export type CurrentReleaseExtendConditionUnion$Outbound = CurrentReleaseExtendCondition$Outbound | string;
+/** @internal */
+export declare const CurrentReleaseExtendConditionUnion$outboundSchema: z.ZodType<CurrentReleaseExtendConditionUnion$Outbound, CurrentReleaseExtendConditionUnion>;
+export declare function currentReleaseExtendConditionUnionToJSON(currentReleaseExtendConditionUnion: CurrentReleaseExtendConditionUnion): string;
+export declare function currentReleaseExtendConditionUnionFromJSON(jsonString: string): SafeParseResult<CurrentReleaseExtendConditionUnion, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseExtendGcpStack$inboundSchema: z.ZodType<CurrentReleaseExtendGcpStack, unknown>;
+/** @internal */
+export type CurrentReleaseExtendGcpStack$Outbound = {
+    condition?: CurrentReleaseExtendCondition$Outbound | string | null | undefined;
+    scope: string;
+};
+/** @internal */
+export declare const CurrentReleaseExtendGcpStack$outboundSchema: z.ZodType<CurrentReleaseExtendGcpStack$Outbound, CurrentReleaseExtendGcpStack>;
+export declare function currentReleaseExtendGcpStackToJSON(currentReleaseExtendGcpStack: CurrentReleaseExtendGcpStack): string;
+export declare function currentReleaseExtendGcpStackFromJSON(jsonString: string): SafeParseResult<CurrentReleaseExtendGcpStack, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseExtendGcpBinding$inboundSchema: z.ZodType<CurrentReleaseExtendGcpBinding, unknown>;
+/** @internal */
+export type CurrentReleaseExtendGcpBinding$Outbound = {
+    resource?: CurrentReleaseExtendGcpResource$Outbound | undefined;
+    stack?: CurrentReleaseExtendGcpStack$Outbound | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseExtendGcpBinding$outboundSchema: z.ZodType<CurrentReleaseExtendGcpBinding$Outbound, CurrentReleaseExtendGcpBinding>;
+export declare function currentReleaseExtendGcpBindingToJSON(currentReleaseExtendGcpBinding: CurrentReleaseExtendGcpBinding): string;
+export declare function currentReleaseExtendGcpBindingFromJSON(jsonString: string): SafeParseResult<CurrentReleaseExtendGcpBinding, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseExtendGcpGrant$inboundSchema: z.ZodType<CurrentReleaseExtendGcpGrant, unknown>;
+/** @internal */
+export type CurrentReleaseExtendGcpGrant$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 CurrentReleaseExtendGcpGrant$outboundSchema: z.ZodType<CurrentReleaseExtendGcpGrant$Outbound, CurrentReleaseExtendGcpGrant>;
+export declare function currentReleaseExtendGcpGrantToJSON(currentReleaseExtendGcpGrant: CurrentReleaseExtendGcpGrant): string;
+export declare function currentReleaseExtendGcpGrantFromJSON(jsonString: string): SafeParseResult<CurrentReleaseExtendGcpGrant, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseExtendGcp$inboundSchema: z.ZodType<CurrentReleaseExtendGcp, unknown>;
+/** @internal */
+export type CurrentReleaseExtendGcp$Outbound = {
+    binding: CurrentReleaseExtendGcpBinding$Outbound;
+    description?: string | null | undefined;
+    grant: CurrentReleaseExtendGcpGrant$Outbound;
+    label?: string | null | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseExtendGcp$outboundSchema: z.ZodType<CurrentReleaseExtendGcp$Outbound, CurrentReleaseExtendGcp>;
+export declare function currentReleaseExtendGcpToJSON(currentReleaseExtendGcp: CurrentReleaseExtendGcp): string;
+export declare function currentReleaseExtendGcpFromJSON(jsonString: string): SafeParseResult<CurrentReleaseExtendGcp, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseExtendPlatforms$inboundSchema: z.ZodType<CurrentReleaseExtendPlatforms, unknown>;
+/** @internal */
+export type CurrentReleaseExtendPlatforms$Outbound = {
+    aws?: Array<CurrentReleaseExtendAw$Outbound> | null | undefined;
+    azure?: Array<CurrentReleaseExtendAzure$Outbound> | null | undefined;
+    gcp?: Array<CurrentReleaseExtendGcp$Outbound> | null | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseExtendPlatforms$outboundSchema: z.ZodType<CurrentReleaseExtendPlatforms$Outbound, CurrentReleaseExtendPlatforms>;
+export declare function currentReleaseExtendPlatformsToJSON(currentReleaseExtendPlatforms: CurrentReleaseExtendPlatforms): string;
+export declare function currentReleaseExtendPlatformsFromJSON(jsonString: string): SafeParseResult<CurrentReleaseExtendPlatforms, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseExtend$inboundSchema: z.ZodType<CurrentReleaseExtend, unknown>;
+/** @internal */
+export type CurrentReleaseExtend$Outbound = {
+    description: string;
+    id: string;
+    platforms: CurrentReleaseExtendPlatforms$Outbound;
+};
+/** @internal */
+export declare const CurrentReleaseExtend$outboundSchema: z.ZodType<CurrentReleaseExtend$Outbound, CurrentReleaseExtend>;
+export declare function currentReleaseExtendToJSON(currentReleaseExtend: CurrentReleaseExtend): string;
+export declare function currentReleaseExtendFromJSON(jsonString: string): SafeParseResult<CurrentReleaseExtend, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseExtendUnion$inboundSchema: z.ZodType<CurrentReleaseExtendUnion, unknown>;
+/** @internal */
+export type CurrentReleaseExtendUnion$Outbound = CurrentReleaseExtend$Outbound | string;
+/** @internal */
+export declare const CurrentReleaseExtendUnion$outboundSchema: z.ZodType<CurrentReleaseExtendUnion$Outbound, CurrentReleaseExtendUnion>;
+export declare function currentReleaseExtendUnionToJSON(currentReleaseExtendUnion: CurrentReleaseExtendUnion): string;
+export declare function currentReleaseExtendUnionFromJSON(jsonString: string): SafeParseResult<CurrentReleaseExtendUnion, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseManagement1$inboundSchema: z.ZodType<CurrentReleaseManagement1, unknown>;
+/** @internal */
+export type CurrentReleaseManagement1$Outbound = {
+    extend: {
+        [k: string]: Array<CurrentReleaseExtend$Outbound | string>;
+    };
+};
+/** @internal */
+export declare const CurrentReleaseManagement1$outboundSchema: z.ZodType<CurrentReleaseManagement1$Outbound, CurrentReleaseManagement1>;
+export declare function currentReleaseManagement1ToJSON(currentReleaseManagement1: CurrentReleaseManagement1): string;
+export declare function currentReleaseManagement1FromJSON(jsonString: string): SafeParseResult<CurrentReleaseManagement1, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseManagementUnion$inboundSchema: z.ZodType<CurrentReleaseManagementUnion, unknown>;
+/** @internal */
+export type CurrentReleaseManagementUnion$Outbound = CurrentReleaseManagement1$Outbound | CurrentReleaseManagement2$Outbound | string;
+/** @internal */
+export declare const CurrentReleaseManagementUnion$outboundSchema: z.ZodType<CurrentReleaseManagementUnion$Outbound, CurrentReleaseManagementUnion>;
+export declare function currentReleaseManagementUnionToJSON(currentReleaseManagementUnion: CurrentReleaseManagementUnion): string;
+export declare function currentReleaseManagementUnionFromJSON(jsonString: string): SafeParseResult<CurrentReleaseManagementUnion, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseProfileAwResource$inboundSchema: z.ZodType<CurrentReleaseProfileAwResource, unknown>;
+/** @internal */
+export type CurrentReleaseProfileAwResource$Outbound = {
+    condition?: {
+        [k: string]: {
+            [k: string]: string;
+        };
+    } | null | undefined;
+    notResources?: Array<string> | undefined;
+    resources: Array<string>;
+};
+/** @internal */
+export declare const CurrentReleaseProfileAwResource$outboundSchema: z.ZodType<CurrentReleaseProfileAwResource$Outbound, CurrentReleaseProfileAwResource>;
+export declare function currentReleaseProfileAwResourceToJSON(currentReleaseProfileAwResource: CurrentReleaseProfileAwResource): string;
+export declare function currentReleaseProfileAwResourceFromJSON(jsonString: string): SafeParseResult<CurrentReleaseProfileAwResource, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseProfileAwStack$inboundSchema: z.ZodType<CurrentReleaseProfileAwStack, unknown>;
+/** @internal */
+export type CurrentReleaseProfileAwStack$Outbound = {
+    condition?: {
+        [k: string]: {
+            [k: string]: string;
+        };
+    } | null | undefined;
+    notResources?: Array<string> | undefined;
+    resources: Array<string>;
+};
+/** @internal */
+export declare const CurrentReleaseProfileAwStack$outboundSchema: z.ZodType<CurrentReleaseProfileAwStack$Outbound, CurrentReleaseProfileAwStack>;
+export declare function currentReleaseProfileAwStackToJSON(currentReleaseProfileAwStack: CurrentReleaseProfileAwStack): string;
+export declare function currentReleaseProfileAwStackFromJSON(jsonString: string): SafeParseResult<CurrentReleaseProfileAwStack, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseProfileAwBinding$inboundSchema: z.ZodType<CurrentReleaseProfileAwBinding, unknown>;
+/** @internal */
+export type CurrentReleaseProfileAwBinding$Outbound = {
+    resource?: CurrentReleaseProfileAwResource$Outbound | undefined;
+    stack?: CurrentReleaseProfileAwStack$Outbound | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseProfileAwBinding$outboundSchema: z.ZodType<CurrentReleaseProfileAwBinding$Outbound, CurrentReleaseProfileAwBinding>;
+export declare function currentReleaseProfileAwBindingToJSON(currentReleaseProfileAwBinding: CurrentReleaseProfileAwBinding): string;
+export declare function currentReleaseProfileAwBindingFromJSON(jsonString: string): SafeParseResult<CurrentReleaseProfileAwBinding, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseProfileEffect$inboundSchema: z.ZodEnum<typeof CurrentReleaseProfileEffect>;
+/** @internal */
+export declare const CurrentReleaseProfileEffect$outboundSchema: z.ZodEnum<typeof CurrentReleaseProfileEffect>;
+/** @internal */
+export declare const CurrentReleaseProfileAwGrant$inboundSchema: z.ZodType<CurrentReleaseProfileAwGrant, unknown>;
+/** @internal */
+export type CurrentReleaseProfileAwGrant$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 CurrentReleaseProfileAwGrant$outboundSchema: z.ZodType<CurrentReleaseProfileAwGrant$Outbound, CurrentReleaseProfileAwGrant>;
+export declare function currentReleaseProfileAwGrantToJSON(currentReleaseProfileAwGrant: CurrentReleaseProfileAwGrant): string;
+export declare function currentReleaseProfileAwGrantFromJSON(jsonString: string): SafeParseResult<CurrentReleaseProfileAwGrant, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseProfileAw$inboundSchema: z.ZodType<CurrentReleaseProfileAw, unknown>;
+/** @internal */
+export type CurrentReleaseProfileAw$Outbound = {
+    binding: CurrentReleaseProfileAwBinding$Outbound;
+    description?: string | null | undefined;
+    effect?: string | undefined;
+    grant: CurrentReleaseProfileAwGrant$Outbound;
+    label?: string | null | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseProfileAw$outboundSchema: z.ZodType<CurrentReleaseProfileAw$Outbound, CurrentReleaseProfileAw>;
+export declare function currentReleaseProfileAwToJSON(currentReleaseProfileAw: CurrentReleaseProfileAw): string;
+export declare function currentReleaseProfileAwFromJSON(jsonString: string): SafeParseResult<CurrentReleaseProfileAw, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseProfileAzureResource$inboundSchema: z.ZodType<CurrentReleaseProfileAzureResource, unknown>;
+/** @internal */
+export type CurrentReleaseProfileAzureResource$Outbound = {
+    scope: string;
+};
+/** @internal */
+export declare const CurrentReleaseProfileAzureResource$outboundSchema: z.ZodType<CurrentReleaseProfileAzureResource$Outbound, CurrentReleaseProfileAzureResource>;
+export declare function currentReleaseProfileAzureResourceToJSON(currentReleaseProfileAzureResource: CurrentReleaseProfileAzureResource): string;
+export declare function currentReleaseProfileAzureResourceFromJSON(jsonString: string): SafeParseResult<CurrentReleaseProfileAzureResource, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseProfileAzureStack$inboundSchema: z.ZodType<CurrentReleaseProfileAzureStack, unknown>;
+/** @internal */
+export type CurrentReleaseProfileAzureStack$Outbound = {
+    scope: string;
+};
+/** @internal */
+export declare const CurrentReleaseProfileAzureStack$outboundSchema: z.ZodType<CurrentReleaseProfileAzureStack$Outbound, CurrentReleaseProfileAzureStack>;
+export declare function currentReleaseProfileAzureStackToJSON(currentReleaseProfileAzureStack: CurrentReleaseProfileAzureStack): string;
+export declare function currentReleaseProfileAzureStackFromJSON(jsonString: string): SafeParseResult<CurrentReleaseProfileAzureStack, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseProfileAzureBinding$inboundSchema: z.ZodType<CurrentReleaseProfileAzureBinding, unknown>;
+/** @internal */
+export type CurrentReleaseProfileAzureBinding$Outbound = {
+    resource?: CurrentReleaseProfileAzureResource$Outbound | undefined;
+    stack?: CurrentReleaseProfileAzureStack$Outbound | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseProfileAzureBinding$outboundSchema: z.ZodType<CurrentReleaseProfileAzureBinding$Outbound, CurrentReleaseProfileAzureBinding>;
+export declare function currentReleaseProfileAzureBindingToJSON(currentReleaseProfileAzureBinding: CurrentReleaseProfileAzureBinding): string;
+export declare function currentReleaseProfileAzureBindingFromJSON(jsonString: string): SafeParseResult<CurrentReleaseProfileAzureBinding, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseProfileAzureGrant$inboundSchema: z.ZodType<CurrentReleaseProfileAzureGrant, unknown>;
+/** @internal */
+export type CurrentReleaseProfileAzureGrant$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 CurrentReleaseProfileAzureGrant$outboundSchema: z.ZodType<CurrentReleaseProfileAzureGrant$Outbound, CurrentReleaseProfileAzureGrant>;
+export declare function currentReleaseProfileAzureGrantToJSON(currentReleaseProfileAzureGrant: CurrentReleaseProfileAzureGrant): string;
+export declare function currentReleaseProfileAzureGrantFromJSON(jsonString: string): SafeParseResult<CurrentReleaseProfileAzureGrant, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseProfileAzure$inboundSchema: z.ZodType<CurrentReleaseProfileAzure, unknown>;
+/** @internal */
+export type CurrentReleaseProfileAzure$Outbound = {
+    binding: CurrentReleaseProfileAzureBinding$Outbound;
+    description?: string | null | undefined;
+    grant: CurrentReleaseProfileAzureGrant$Outbound;
+    label?: string | null | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseProfileAzure$outboundSchema: z.ZodType<CurrentReleaseProfileAzure$Outbound, CurrentReleaseProfileAzure>;
+export declare function currentReleaseProfileAzureToJSON(currentReleaseProfileAzure: CurrentReleaseProfileAzure): string;
+export declare function currentReleaseProfileAzureFromJSON(jsonString: string): SafeParseResult<CurrentReleaseProfileAzure, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseProfileConditionResource$inboundSchema: z.ZodType<CurrentReleaseProfileConditionResource, unknown>;
+/** @internal */
+export type CurrentReleaseProfileConditionResource$Outbound = {
+    expression: string;
+    title: string;
+};
+/** @internal */
+export declare const CurrentReleaseProfileConditionResource$outboundSchema: z.ZodType<CurrentReleaseProfileConditionResource$Outbound, CurrentReleaseProfileConditionResource>;
+export declare function currentReleaseProfileConditionResourceToJSON(currentReleaseProfileConditionResource: CurrentReleaseProfileConditionResource): string;
+export declare function currentReleaseProfileConditionResourceFromJSON(jsonString: string): SafeParseResult<CurrentReleaseProfileConditionResource, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseProfileResourceConditionUnion$inboundSchema: z.ZodType<CurrentReleaseProfileResourceConditionUnion, unknown>;
+/** @internal */
+export type CurrentReleaseProfileResourceConditionUnion$Outbound = CurrentReleaseProfileConditionResource$Outbound | string;
+/** @internal */
+export declare const CurrentReleaseProfileResourceConditionUnion$outboundSchema: z.ZodType<CurrentReleaseProfileResourceConditionUnion$Outbound, CurrentReleaseProfileResourceConditionUnion>;
+export declare function currentReleaseProfileResourceConditionUnionToJSON(currentReleaseProfileResourceConditionUnion: CurrentReleaseProfileResourceConditionUnion): string;
+export declare function currentReleaseProfileResourceConditionUnionFromJSON(jsonString: string): SafeParseResult<CurrentReleaseProfileResourceConditionUnion, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseProfileGcpResource$inboundSchema: z.ZodType<CurrentReleaseProfileGcpResource, unknown>;
+/** @internal */
+export type CurrentReleaseProfileGcpResource$Outbound = {
+    condition?: CurrentReleaseProfileConditionResource$Outbound | string | null | undefined;
+    scope: string;
+};
+/** @internal */
+export declare const CurrentReleaseProfileGcpResource$outboundSchema: z.ZodType<CurrentReleaseProfileGcpResource$Outbound, CurrentReleaseProfileGcpResource>;
+export declare function currentReleaseProfileGcpResourceToJSON(currentReleaseProfileGcpResource: CurrentReleaseProfileGcpResource): string;
+export declare function currentReleaseProfileGcpResourceFromJSON(jsonString: string): SafeParseResult<CurrentReleaseProfileGcpResource, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseProfileCondition$inboundSchema: z.ZodType<CurrentReleaseProfileCondition, unknown>;
+/** @internal */
+export type CurrentReleaseProfileCondition$Outbound = {
+    expression: string;
+    title: string;
+};
+/** @internal */
+export declare const CurrentReleaseProfileCondition$outboundSchema: z.ZodType<CurrentReleaseProfileCondition$Outbound, CurrentReleaseProfileCondition>;
+export declare function currentReleaseProfileConditionToJSON(currentReleaseProfileCondition: CurrentReleaseProfileCondition): string;
+export declare function currentReleaseProfileConditionFromJSON(jsonString: string): SafeParseResult<CurrentReleaseProfileCondition, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseProfileConditionUnion$inboundSchema: z.ZodType<CurrentReleaseProfileConditionUnion, unknown>;
+/** @internal */
+export type CurrentReleaseProfileConditionUnion$Outbound = CurrentReleaseProfileCondition$Outbound | string;
+/** @internal */
+export declare const CurrentReleaseProfileConditionUnion$outboundSchema: z.ZodType<CurrentReleaseProfileConditionUnion$Outbound, CurrentReleaseProfileConditionUnion>;
+export declare function currentReleaseProfileConditionUnionToJSON(currentReleaseProfileConditionUnion: CurrentReleaseProfileConditionUnion): string;
+export declare function currentReleaseProfileConditionUnionFromJSON(jsonString: string): SafeParseResult<CurrentReleaseProfileConditionUnion, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseProfileGcpStack$inboundSchema: z.ZodType<CurrentReleaseProfileGcpStack, unknown>;
+/** @internal */
+export type CurrentReleaseProfileGcpStack$Outbound = {
+    condition?: CurrentReleaseProfileCondition$Outbound | string | null | undefined;
+    scope: string;
+};
+/** @internal */
+export declare const CurrentReleaseProfileGcpStack$outboundSchema: z.ZodType<CurrentReleaseProfileGcpStack$Outbound, CurrentReleaseProfileGcpStack>;
+export declare function currentReleaseProfileGcpStackToJSON(currentReleaseProfileGcpStack: CurrentReleaseProfileGcpStack): string;
+export declare function currentReleaseProfileGcpStackFromJSON(jsonString: string): SafeParseResult<CurrentReleaseProfileGcpStack, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseProfileGcpBinding$inboundSchema: z.ZodType<CurrentReleaseProfileGcpBinding, unknown>;
+/** @internal */
+export type CurrentReleaseProfileGcpBinding$Outbound = {
+    resource?: CurrentReleaseProfileGcpResource$Outbound | undefined;
+    stack?: CurrentReleaseProfileGcpStack$Outbound | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseProfileGcpBinding$outboundSchema: z.ZodType<CurrentReleaseProfileGcpBinding$Outbound, CurrentReleaseProfileGcpBinding>;
+export declare function currentReleaseProfileGcpBindingToJSON(currentReleaseProfileGcpBinding: CurrentReleaseProfileGcpBinding): string;
+export declare function currentReleaseProfileGcpBindingFromJSON(jsonString: string): SafeParseResult<CurrentReleaseProfileGcpBinding, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseProfileGcpGrant$inboundSchema: z.ZodType<CurrentReleaseProfileGcpGrant, unknown>;
+/** @internal */
+export type CurrentReleaseProfileGcpGrant$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 CurrentReleaseProfileGcpGrant$outboundSchema: z.ZodType<CurrentReleaseProfileGcpGrant$Outbound, CurrentReleaseProfileGcpGrant>;
+export declare function currentReleaseProfileGcpGrantToJSON(currentReleaseProfileGcpGrant: CurrentReleaseProfileGcpGrant): string;
+export declare function currentReleaseProfileGcpGrantFromJSON(jsonString: string): SafeParseResult<CurrentReleaseProfileGcpGrant, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseProfileGcp$inboundSchema: z.ZodType<CurrentReleaseProfileGcp, unknown>;
+/** @internal */
+export type CurrentReleaseProfileGcp$Outbound = {
+    binding: CurrentReleaseProfileGcpBinding$Outbound;
+    description?: string | null | undefined;
+    grant: CurrentReleaseProfileGcpGrant$Outbound;
+    label?: string | null | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseProfileGcp$outboundSchema: z.ZodType<CurrentReleaseProfileGcp$Outbound, CurrentReleaseProfileGcp>;
+export declare function currentReleaseProfileGcpToJSON(currentReleaseProfileGcp: CurrentReleaseProfileGcp): string;
+export declare function currentReleaseProfileGcpFromJSON(jsonString: string): SafeParseResult<CurrentReleaseProfileGcp, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseProfilePlatforms$inboundSchema: z.ZodType<CurrentReleaseProfilePlatforms, unknown>;
+/** @internal */
+export type CurrentReleaseProfilePlatforms$Outbound = {
+    aws?: Array<CurrentReleaseProfileAw$Outbound> | null | undefined;
+    azure?: Array<CurrentReleaseProfileAzure$Outbound> | null | undefined;
+    gcp?: Array<CurrentReleaseProfileGcp$Outbound> | null | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseProfilePlatforms$outboundSchema: z.ZodType<CurrentReleaseProfilePlatforms$Outbound, CurrentReleaseProfilePlatforms>;
+export declare function currentReleaseProfilePlatformsToJSON(currentReleaseProfilePlatforms: CurrentReleaseProfilePlatforms): string;
+export declare function currentReleaseProfilePlatformsFromJSON(jsonString: string): SafeParseResult<CurrentReleaseProfilePlatforms, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseProfile$inboundSchema: z.ZodType<CurrentReleaseProfile, unknown>;
+/** @internal */
+export type CurrentReleaseProfile$Outbound = {
+    description: string;
+    id: string;
+    platforms: CurrentReleaseProfilePlatforms$Outbound;
+};
+/** @internal */
+export declare const CurrentReleaseProfile$outboundSchema: z.ZodType<CurrentReleaseProfile$Outbound, CurrentReleaseProfile>;
+export declare function currentReleaseProfileToJSON(currentReleaseProfile: CurrentReleaseProfile): string;
+export declare function currentReleaseProfileFromJSON(jsonString: string): SafeParseResult<CurrentReleaseProfile, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseProfileUnion$inboundSchema: z.ZodType<CurrentReleaseProfileUnion, unknown>;
+/** @internal */
+export type CurrentReleaseProfileUnion$Outbound = CurrentReleaseProfile$Outbound | string;
+/** @internal */
+export declare const CurrentReleaseProfileUnion$outboundSchema: z.ZodType<CurrentReleaseProfileUnion$Outbound, CurrentReleaseProfileUnion>;
+export declare function currentReleaseProfileUnionToJSON(currentReleaseProfileUnion: CurrentReleaseProfileUnion): string;
+export declare function currentReleaseProfileUnionFromJSON(jsonString: string): SafeParseResult<CurrentReleaseProfileUnion, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleasePermissions$inboundSchema: z.ZodType<CurrentReleasePermissions, unknown>;
+/** @internal */
+export type CurrentReleasePermissions$Outbound = {
+    management?: CurrentReleaseManagement1$Outbound | CurrentReleaseManagement2$Outbound | string | undefined;
+    profiles: {
+        [k: string]: {
+            [k: string]: Array<CurrentReleaseProfile$Outbound | string>;
+        };
+    };
+};
+/** @internal */
+export declare const CurrentReleasePermissions$outboundSchema: z.ZodType<CurrentReleasePermissions$Outbound, CurrentReleasePermissions>;
+export declare function currentReleasePermissionsToJSON(currentReleasePermissions: CurrentReleasePermissions): string;
+export declare function currentReleasePermissionsFromJSON(jsonString: string): SafeParseResult<CurrentReleasePermissions, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseConfig$inboundSchema: z.ZodType<CurrentReleaseConfig, unknown>;
+/** @internal */
+export type CurrentReleaseConfig$Outbound = {
+    id: string;
+    type: string;
+    [additionalProperties: string]: unknown;
+};
+/** @internal */
+export declare const CurrentReleaseConfig$outboundSchema: z.ZodType<CurrentReleaseConfig$Outbound, CurrentReleaseConfig>;
+export declare function currentReleaseConfigToJSON(currentReleaseConfig: CurrentReleaseConfig): string;
+export declare function currentReleaseConfigFromJSON(jsonString: string): SafeParseResult<CurrentReleaseConfig, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseDependency$inboundSchema: z.ZodType<CurrentReleaseDependency, unknown>;
+/** @internal */
+export type CurrentReleaseDependency$Outbound = {
+    id: string;
+    type: string;
+};
+/** @internal */
+export declare const CurrentReleaseDependency$outboundSchema: z.ZodType<CurrentReleaseDependency$Outbound, CurrentReleaseDependency>;
+export declare function currentReleaseDependencyToJSON(currentReleaseDependency: CurrentReleaseDependency): string;
+export declare function currentReleaseDependencyFromJSON(jsonString: string): SafeParseResult<CurrentReleaseDependency, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseLifecycle$inboundSchema: z.ZodEnum<typeof CurrentReleaseLifecycle>;
+/** @internal */
+export declare const CurrentReleaseLifecycle$outboundSchema: z.ZodEnum<typeof CurrentReleaseLifecycle>;
+/** @internal */
+export declare const CurrentReleaseResources$inboundSchema: z.ZodType<CurrentReleaseResources, unknown>;
+/** @internal */
+export type CurrentReleaseResources$Outbound = {
+    config: CurrentReleaseConfig$Outbound;
+    dependencies: Array<CurrentReleaseDependency$Outbound>;
+    description?: string | null | undefined;
+    displayName?: string | null | undefined;
+    enabledWhen?: string | null | undefined;
+    lifecycle: string;
+    remoteAccess?: boolean | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseResources$outboundSchema: z.ZodType<CurrentReleaseResources$Outbound, CurrentReleaseResources>;
+export declare function currentReleaseResourcesToJSON(currentReleaseResources: CurrentReleaseResources): string;
+export declare function currentReleaseResourcesFromJSON(jsonString: string): SafeParseResult<CurrentReleaseResources, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseSupportedPlatform$inboundSchema: z.ZodEnum<typeof CurrentReleaseSupportedPlatform>;
+/** @internal */
+export declare const CurrentReleaseSupportedPlatform$outboundSchema: z.ZodEnum<typeof CurrentReleaseSupportedPlatform>;
+/** @internal */
+export declare const CurrentReleaseStack$inboundSchema: z.ZodType<CurrentReleaseStack, unknown>;
+/** @internal */
+export type CurrentReleaseStack$Outbound = {
+    dynamicContainerImageResources?: Array<string> | undefined;
+    dynamicContainerRepositories?: Array<string> | undefined;
+    id: string;
+    inputs?: Array<CurrentReleaseInput$Outbound> | undefined;
+    operations?: CurrentReleaseOperations$Outbound | string | null | undefined;
+    permissions?: CurrentReleasePermissions$Outbound | undefined;
+    resources: {
+        [k: string]: CurrentReleaseResources$Outbound;
+    };
+    supportedPlatforms?: Array<string> | null | undefined;
+};
+/** @internal */
+export declare const CurrentReleaseStack$outboundSchema: z.ZodType<CurrentReleaseStack$Outbound, CurrentReleaseStack>;
+export declare function currentReleaseStackToJSON(currentReleaseStack: CurrentReleaseStack): string;
+export declare function currentReleaseStackFromJSON(jsonString: string): SafeParseResult<CurrentReleaseStack, SDKValidationError>;
+/** @internal */
+export declare const CurrentRelease$inboundSchema: z.ZodType<CurrentRelease, unknown>;
+/** @internal */
+export type CurrentRelease$Outbound = {
+    description?: string | null | undefined;
+    releaseId?: string | null | undefined;
+    stack: CurrentReleaseStack$Outbound;
+    version?: string | null | undefined;
+};
+/** @internal */
+export declare const CurrentRelease$outboundSchema: z.ZodType<CurrentRelease$Outbound, CurrentRelease>;
+export declare function currentReleaseToJSON(currentRelease: CurrentRelease): string;
+export declare function currentReleaseFromJSON(jsonString: string): SafeParseResult<CurrentRelease, SDKValidationError>;
+/** @internal */
+export declare const CurrentReleaseUnion$inboundSchema: z.ZodType<CurrentReleaseUnion, unknown>;
+/** @internal */
+export type CurrentReleaseUnion$Outbound = CurrentRelease$Outbound | string;
+/** @internal */
+export declare const CurrentReleaseUnion$outboundSchema: z.ZodType<CurrentReleaseUnion$Outbound, CurrentReleaseUnion>;
+export declare function currentReleaseUnionToJSON(currentReleaseUnion: CurrentReleaseUnion): string;
+export declare function currentReleaseUnionFromJSON(jsonString: string): SafeParseResult<CurrentReleaseUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePlatformTest$inboundSchema: z.ZodEnum<typeof DeploymentStatePlatformTest>;
+/** @internal */
+export declare const DeploymentStatePlatformTest$outboundSchema: z.ZodEnum<typeof DeploymentStatePlatformTest>;
+/** @internal */
+export declare const DeploymentStateEnvironmentInfoTest$inboundSchema: z.ZodType<DeploymentStateEnvironmentInfoTest, unknown>;
+/** @internal */
+export type DeploymentStateEnvironmentInfoTest$Outbound = {
+    testId: string;
+    platform: string;
+};
+/** @internal */
+export declare const DeploymentStateEnvironmentInfoTest$outboundSchema: z.ZodType<DeploymentStateEnvironmentInfoTest$Outbound, DeploymentStateEnvironmentInfoTest>;
+export declare function deploymentStateEnvironmentInfoTestToJSON(deploymentStateEnvironmentInfoTest: DeploymentStateEnvironmentInfoTest): string;
+export declare function deploymentStateEnvironmentInfoTestFromJSON(jsonString: string): SafeParseResult<DeploymentStateEnvironmentInfoTest, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePlatformLocal$inboundSchema: z.ZodEnum<typeof DeploymentStatePlatformLocal>;
+/** @internal */
+export declare const DeploymentStatePlatformLocal$outboundSchema: z.ZodEnum<typeof DeploymentStatePlatformLocal>;
+/** @internal */
+export declare const DeploymentStateEnvironmentInfoLocal$inboundSchema: z.ZodType<DeploymentStateEnvironmentInfoLocal, unknown>;
+/** @internal */
+export type DeploymentStateEnvironmentInfoLocal$Outbound = {
+    arch: string;
+    hostname: string;
+    os: string;
+    platform: string;
+};
+/** @internal */
+export declare const DeploymentStateEnvironmentInfoLocal$outboundSchema: z.ZodType<DeploymentStateEnvironmentInfoLocal$Outbound, DeploymentStateEnvironmentInfoLocal>;
+export declare function deploymentStateEnvironmentInfoLocalToJSON(deploymentStateEnvironmentInfoLocal: DeploymentStateEnvironmentInfoLocal): string;
+export declare function deploymentStateEnvironmentInfoLocalFromJSON(jsonString: string): SafeParseResult<DeploymentStateEnvironmentInfoLocal, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePlatformAzure$inboundSchema: z.ZodEnum<typeof DeploymentStatePlatformAzure>;
+/** @internal */
+export declare const DeploymentStatePlatformAzure$outboundSchema: z.ZodEnum<typeof DeploymentStatePlatformAzure>;
+/** @internal */
+export declare const DeploymentStateEnvironmentInfoAzure$inboundSchema: z.ZodType<DeploymentStateEnvironmentInfoAzure, unknown>;
+/** @internal */
+export type DeploymentStateEnvironmentInfoAzure$Outbound = {
+    location: string;
+    subscriptionId: string;
+    tenantId: string;
+    platform: string;
+};
+/** @internal */
+export declare const DeploymentStateEnvironmentInfoAzure$outboundSchema: z.ZodType<DeploymentStateEnvironmentInfoAzure$Outbound, DeploymentStateEnvironmentInfoAzure>;
+export declare function deploymentStateEnvironmentInfoAzureToJSON(deploymentStateEnvironmentInfoAzure: DeploymentStateEnvironmentInfoAzure): string;
+export declare function deploymentStateEnvironmentInfoAzureFromJSON(jsonString: string): SafeParseResult<DeploymentStateEnvironmentInfoAzure, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePlatformGcp$inboundSchema: z.ZodEnum<typeof DeploymentStatePlatformGcp>;
+/** @internal */
+export declare const DeploymentStatePlatformGcp$outboundSchema: z.ZodEnum<typeof DeploymentStatePlatformGcp>;
+/** @internal */
+export declare const DeploymentStateEnvironmentInfoGcp$inboundSchema: z.ZodType<DeploymentStateEnvironmentInfoGcp, unknown>;
+/** @internal */
+export type DeploymentStateEnvironmentInfoGcp$Outbound = {
+    projectId: string;
+    projectNumber: string;
+    region: string;
+    platform: string;
+};
+/** @internal */
+export declare const DeploymentStateEnvironmentInfoGcp$outboundSchema: z.ZodType<DeploymentStateEnvironmentInfoGcp$Outbound, DeploymentStateEnvironmentInfoGcp>;
+export declare function deploymentStateEnvironmentInfoGcpToJSON(deploymentStateEnvironmentInfoGcp: DeploymentStateEnvironmentInfoGcp): string;
+export declare function deploymentStateEnvironmentInfoGcpFromJSON(jsonString: string): SafeParseResult<DeploymentStateEnvironmentInfoGcp, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePlatformAws$inboundSchema: z.ZodEnum<typeof DeploymentStatePlatformAws>;
+/** @internal */
+export declare const DeploymentStatePlatformAws$outboundSchema: z.ZodEnum<typeof DeploymentStatePlatformAws>;
+/** @internal */
+export declare const DeploymentStateEnvironmentInfoAws$inboundSchema: z.ZodType<DeploymentStateEnvironmentInfoAws, unknown>;
+/** @internal */
+export type DeploymentStateEnvironmentInfoAws$Outbound = {
+    accountId: string;
+    region: string;
+    platform: string;
+};
+/** @internal */
+export declare const DeploymentStateEnvironmentInfoAws$outboundSchema: z.ZodType<DeploymentStateEnvironmentInfoAws$Outbound, DeploymentStateEnvironmentInfoAws>;
+export declare function deploymentStateEnvironmentInfoAwsToJSON(deploymentStateEnvironmentInfoAws: DeploymentStateEnvironmentInfoAws): string;
+export declare function deploymentStateEnvironmentInfoAwsFromJSON(jsonString: string): SafeParseResult<DeploymentStateEnvironmentInfoAws, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateEnvironmentInfoUnion$inboundSchema: z.ZodType<DeploymentStateEnvironmentInfoUnion, unknown>;
+/** @internal */
+export type DeploymentStateEnvironmentInfoUnion$Outbound = DeploymentStateEnvironmentInfoGcp$Outbound | DeploymentStateEnvironmentInfoAzure$Outbound | DeploymentStateEnvironmentInfoLocal$Outbound | DeploymentStateEnvironmentInfoAws$Outbound | DeploymentStateEnvironmentInfoTest$Outbound | string;
+/** @internal */
+export declare const DeploymentStateEnvironmentInfoUnion$outboundSchema: z.ZodType<DeploymentStateEnvironmentInfoUnion$Outbound, DeploymentStateEnvironmentInfoUnion>;
+export declare function deploymentStateEnvironmentInfoUnionToJSON(deploymentStateEnvironmentInfoUnion: DeploymentStateEnvironmentInfoUnion): string;
+export declare function deploymentStateEnvironmentInfoUnionFromJSON(jsonString: string): SafeParseResult<DeploymentStateEnvironmentInfoUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateError$inboundSchema: z.ZodType<DeploymentStateError, unknown>;
+/** @internal */
+export type DeploymentStateError$Outbound = {
+    code: string;
+    context?: any | null | undefined;
+    hint?: string | null | undefined;
+    httpStatusCode?: number | null | undefined;
+    internal: boolean;
+    message: string;
+    retryable: boolean;
+    source?: any | null | undefined;
+};
+/** @internal */
+export declare const DeploymentStateError$outboundSchema: z.ZodType<DeploymentStateError$Outbound, DeploymentStateError>;
+export declare function deploymentStateErrorToJSON(deploymentStateError: DeploymentStateError): string;
+export declare function deploymentStateErrorFromJSON(jsonString: string): SafeParseResult<DeploymentStateError, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateErrorUnion$inboundSchema: z.ZodType<DeploymentStateErrorUnion, unknown>;
+/** @internal */
+export type DeploymentStateErrorUnion$Outbound = DeploymentStateError$Outbound | string;
+/** @internal */
+export declare const DeploymentStateErrorUnion$outboundSchema: z.ZodType<DeploymentStateErrorUnion$Outbound, DeploymentStateErrorUnion>;
+export declare function deploymentStateErrorUnionToJSON(deploymentStateErrorUnion: DeploymentStateErrorUnion): string;
+export declare function deploymentStateErrorUnionFromJSON(jsonString: string): SafeParseResult<DeploymentStateErrorUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStatePlatform$inboundSchema: z.ZodEnum<typeof DeploymentStatePlatform>;
+/** @internal */
+export declare const DeploymentStatePlatform$outboundSchema: z.ZodEnum<typeof DeploymentStatePlatform>;
+/** @internal */
+export declare const DeploymentStateCredentialRetryStatus$inboundSchema: z.ZodEnum<typeof DeploymentStateCredentialRetryStatus>;
+/** @internal */
+export declare const DeploymentStateCredentialRetryStatus$outboundSchema: z.ZodEnum<typeof DeploymentStateCredentialRetryStatus>;
+/** @internal */
+export declare const DeploymentStateCredentialRetry$inboundSchema: z.ZodType<DeploymentStateCredentialRetry, unknown>;
+/** @internal */
+export type DeploymentStateCredentialRetry$Outbound = {
+    startedAt: string;
+    status: string;
+};
+/** @internal */
+export declare const DeploymentStateCredentialRetry$outboundSchema: z.ZodType<DeploymentStateCredentialRetry$Outbound, DeploymentStateCredentialRetry>;
+export declare function deploymentStateCredentialRetryToJSON(deploymentStateCredentialRetry: DeploymentStateCredentialRetry): string;
+export declare function deploymentStateCredentialRetryFromJSON(jsonString: string): SafeParseResult<DeploymentStateCredentialRetry, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateCredentialRetryUnion$inboundSchema: z.ZodType<DeploymentStateCredentialRetryUnion, unknown>;
+/** @internal */
+export type DeploymentStateCredentialRetryUnion$Outbound = DeploymentStateCredentialRetry$Outbound | string;
+/** @internal */
+export declare const DeploymentStateCredentialRetryUnion$outboundSchema: z.ZodType<DeploymentStateCredentialRetryUnion$Outbound, DeploymentStateCredentialRetryUnion>;
+export declare function deploymentStateCredentialRetryUnionToJSON(deploymentStateCredentialRetryUnion: DeploymentStateCredentialRetryUnion): string;
+export declare function deploymentStateCredentialRetryUnionFromJSON(jsonString: string): SafeParseResult<DeploymentStateCredentialRetryUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateDeletionPolicy$inboundSchema: z.ZodEnum<typeof DeploymentStateDeletionPolicy>;
+/** @internal */
+export declare const DeploymentStateDeletionPolicy$outboundSchema: z.ZodEnum<typeof DeploymentStateDeletionPolicy>;
+/** @internal */
+export declare const DeploymentStateUnix$inboundSchema: z.ZodType<DeploymentStateUnix, unknown>;
+/** @internal */
+export type DeploymentStateUnix$Outbound = {
+    inline: string;
+    prompt: string;
+};
+/** @internal */
+export declare const DeploymentStateUnix$outboundSchema: z.ZodType<DeploymentStateUnix$Outbound, DeploymentStateUnix>;
+export declare function deploymentStateUnixToJSON(deploymentStateUnix: DeploymentStateUnix): string;
+export declare function deploymentStateUnixFromJSON(jsonString: string): SafeParseResult<DeploymentStateUnix, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateWindows$inboundSchema: z.ZodType<DeploymentStateWindows, unknown>;
+/** @internal */
+export type DeploymentStateWindows$Outbound = {
+    inline: string;
+    prompt: string;
+};
+/** @internal */
+export declare const DeploymentStateWindows$outboundSchema: z.ZodType<DeploymentStateWindows$Outbound, DeploymentStateWindows>;
+export declare function deploymentStateWindowsToJSON(deploymentStateWindows: DeploymentStateWindows): string;
+export declare function deploymentStateWindowsFromJSON(jsonString: string): SafeParseResult<DeploymentStateWindows, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateCommands$inboundSchema: z.ZodType<DeploymentStateCommands, unknown>;
+/** @internal */
+export type DeploymentStateCommands$Outbound = {
+    checkCommand?: string | null | undefined;
+    target?: string | null | undefined;
+    unix: DeploymentStateUnix$Outbound;
+    windows: DeploymentStateWindows$Outbound;
+};
+/** @internal */
+export declare const DeploymentStateCommands$outboundSchema: z.ZodType<DeploymentStateCommands$Outbound, DeploymentStateCommands>;
+export declare function deploymentStateCommandsToJSON(deploymentStateCommands: DeploymentStateCommands): string;
+export declare function deploymentStateCommandsFromJSON(jsonString: string): SafeParseResult<DeploymentStateCommands, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateCommandsUnion$inboundSchema: z.ZodType<DeploymentStateCommandsUnion, unknown>;
+/** @internal */
+export type DeploymentStateCommandsUnion$Outbound = DeploymentStateCommands$Outbound | string;
+/** @internal */
+export declare const DeploymentStateCommandsUnion$outboundSchema: z.ZodType<DeploymentStateCommandsUnion$Outbound, DeploymentStateCommandsUnion>;
+export declare function deploymentStateCommandsUnionToJSON(deploymentStateCommandsUnion: DeploymentStateCommandsUnion): string;
+export declare function deploymentStateCommandsUnionFromJSON(jsonString: string): SafeParseResult<DeploymentStateCommandsUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateStore$inboundSchema: z.ZodEnum<typeof DeploymentStateStore>;
+/** @internal */
+export declare const DeploymentStateStore$outboundSchema: z.ZodEnum<typeof DeploymentStateStore>;
+/** @internal */
+export declare const DeploymentStateLocation$inboundSchema: z.ZodType<DeploymentStateLocation, unknown>;
+/** @internal */
+export type DeploymentStateLocation$Outbound = {
+    cliCommand: string;
+    commands?: DeploymentStateCommands$Outbound | string | null | undefined;
+    consoleUrl?: string | null | undefined;
+    deleteCommand?: string | null | undefined;
+    name: string;
+    store: string;
+    vaultName?: string | null | undefined;
+};
+/** @internal */
+export declare const DeploymentStateLocation$outboundSchema: z.ZodType<DeploymentStateLocation$Outbound, DeploymentStateLocation>;
+export declare function deploymentStateLocationToJSON(deploymentStateLocation: DeploymentStateLocation): string;
+export declare function deploymentStateLocationFromJSON(jsonString: string): SafeParseResult<DeploymentStateLocation, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateDeployerSecretStatus$inboundSchema: z.ZodEnum<typeof DeploymentStateDeployerSecretStatus>;
+/** @internal */
+export declare const DeploymentStateDeployerSecretStatus$outboundSchema: z.ZodEnum<typeof DeploymentStateDeployerSecretStatus>;
+/** @internal */
+export declare const DeploymentStateDeployerSecret$inboundSchema: z.ZodType<DeploymentStateDeployerSecret, unknown>;
+/** @internal */
+export type DeploymentStateDeployerSecret$Outbound = {
+    inputId: string;
+    label: string;
+    location: DeploymentStateLocation$Outbound;
+    message?: string | null | undefined;
+    required: boolean;
+    status: string;
+    version?: string | null | undefined;
+};
+/** @internal */
+export declare const DeploymentStateDeployerSecret$outboundSchema: z.ZodType<DeploymentStateDeployerSecret$Outbound, DeploymentStateDeployerSecret>;
+export declare function deploymentStateDeployerSecretToJSON(deploymentStateDeployerSecret: DeploymentStateDeployerSecret): string;
+export declare function deploymentStateDeployerSecretFromJSON(jsonString: string): SafeParseResult<DeploymentStateDeployerSecret, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStateInitialSetupAuthority$inboundSchema: z.ZodEnum<typeof DeploymentStateInitialSetupAuthority>;
+/** @internal */
+export declare const DeploymentStateInitialSetupAuthority$outboundSchema: z.ZodEnum<typeof DeploymentStateInitialSetupAuthority>;
+/** @internal */
+export declare const DeploymentStatePendingPreparedStackTypeStringList$inboundSchema: z.ZodEnum<typeof DeploymentStatePendingPreparedStackTypeStringList>;
+/** @internal */
+export declare const DeploymentStatePendingPreparedStackTypeStringList$outboundSchema: z.ZodEnum<typeof DeploymentStatePendingPreparedStackTypeStringList>;
+export declare const DeploymentStateRuntimeMetadataStatus: {
+    readonly Present: "present";
+    readonly Missing: "missing";
+    readonly Invalid: "invalid";
+};
+export type DeploymentStateRuntimeMetadataStatus = DeploymentStateDeployerSecretStatus;
+export declare const DeploymentStateRuntimeMetadataStatus$inboundSchema: z.ZodEnum<{
+    readonly Present: "present";
+    readonly Missing: "missing";
+    readonly Invalid: "invalid";
+}>;
+export declare const DeploymentStateRuntimeMetadataStatus$outboundSchema: z.ZodEnum<{
+    readonly Present: "present";
+    readonly Missing: "missing";
+    readonly Invalid: "invalid";
+}>;
+//# sourceMappingURL=deploymentstatependingpreparedstacktypestringlist.d.ts.map