@alienplatform/platform-api 3.3.40 → 3.3.42-dev.6e3a661b219b3886d55014b3cef8af0ecdcc65fe

package/esm/models/externalbindingecr.d.ts

@@ -0,0 +1,2868 @@
+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";
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type ApiKeySecretRef = {
+    key: string;
+    name: string;
+};
+export type ExternalBindingApiKey = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: ApiKeySecretRef;
+};
+export declare const TypeAi: {
+    readonly Ai: "ai";
+};
+export type TypeAi = ClosedEnum<typeof TypeAi>;
+/**
+ * External AI provider binding configuration (BYO-key).
+ *
+ * @remarks
+ *
+ * The operator-supplied secret rides inside the binding via
+ * `BindingValue<String>`, so it is a literal on cloud platforms and gains
+ * Kubernetes SecretRef resolution for free (`extract_binding_secrets` walks
+ * the binding JSON for `secretRef`).
+ */
+export type ExternalBindingAi = {
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    apiKey: any | null;
+    /**
+     * The external AI provider name (e.g., "openai", "anthropic")
+     */
+    provider: string;
+    type: TypeAi;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type DatabaseSecretRef7 = {
+    key: string;
+    name: string;
+};
+export type Database7 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: DatabaseSecretRef7;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type HostSecretRef4 = {
+    key: string;
+    name: string;
+};
+export type Host4 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: HostSecretRef4;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type PortSecretRef6 = {
+    key: string;
+    name: string;
+};
+export type Port6 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: PortSecretRef6;
+};
+/**
+ * Represents a value that can be either a concrete value, a template expression,
+ *
+ * @remarks
+ * or a reference to a Kubernetes Secret
+ */
+export type PortUnion6 = Port6 | number | any | string;
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type UsernameSecretRef6 = {
+    key: string;
+    name: string;
+};
+export type ExternalBindingUsername6 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: UsernameSecretRef6;
+};
+export declare const TypePostgres6: {
+    readonly Postgres: "postgres";
+};
+export type TypePostgres6 = ClosedEnum<typeof TypePostgres6>;
+/**
+ * Local embedded Postgres binding.
+ */
+export type ExternalBindingLocalPostgres = {
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    database: any | null;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    host: any | null;
+    password: string;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    port: Port6 | number | any | string | null;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    username: any | null;
+    service: "local-postgres";
+    type: TypePostgres6;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type DatabaseSecretRef6 = {
+    key: string;
+    name: string;
+};
+export type Database6 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: DatabaseSecretRef6;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type HostSecretRef3 = {
+    key: string;
+    name: string;
+};
+export type Host3 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: HostSecretRef3;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type PortSecretRef5 = {
+    key: string;
+    name: string;
+};
+export type Port5 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: PortSecretRef5;
+};
+/**
+ * Represents a value that can be either a concrete value, a template expression,
+ *
+ * @remarks
+ * or a reference to a Kubernetes Secret
+ */
+export type PortUnion5 = Port5 | number | any | string;
+/**
+ * TLS policy for an operator-provided / BYO Postgres database.
+ *
+ * @remarks
+ *
+ * Unlike libpq's ambiguous `prefer` mode, both choices map exactly to the
+ * connection settings exposed by every supported SDK.
+ */
+export declare const SslMode: {
+    readonly VerifyFull: "verify-full";
+    readonly Disable: "disable";
+};
+/**
+ * TLS policy for an operator-provided / BYO Postgres database.
+ *
+ * @remarks
+ *
+ * Unlike libpq's ambiguous `prefer` mode, both choices map exactly to the
+ * connection settings exposed by every supported SDK.
+ */
+export type SslMode = ClosedEnum<typeof SslMode>;
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type UsernameSecretRef5 = {
+    key: string;
+    name: string;
+};
+export type ExternalBindingUsername5 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: UsernameSecretRef5;
+};
+export declare const TypePostgres5: {
+    readonly Postgres: "postgres";
+};
+export type TypePostgres5 = ClosedEnum<typeof TypePostgres5>;
+/**
+ * Operator-provided / BYO database binding.
+ */
+export type ExternalBindingExternal = {
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    database: any | null;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    host: any | null;
+    /**
+     * Connection password as a concrete value, never an unresolved `SecretRef`: the platform
+     *
+     * @remarks
+     * materializes the Kubernetes secret into the pod env. The cloud variants carry a secret
+     * locator instead.
+     */
+    password: string;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    port: Port5 | number | any | string | null;
+    /**
+     * TLS policy for an operator-provided / BYO Postgres database.
+     *
+     * @remarks
+     *
+     * Unlike libpq's ambiguous `prefer` mode, both choices map exactly to the
+     * connection settings exposed by every supported SDK.
+     */
+    sslMode?: SslMode | undefined;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    username: any | null;
+    service: "external";
+    type: TypePostgres5;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type DatabaseSecretRef5 = {
+    key: string;
+    name: string;
+};
+export type Database5 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: DatabaseSecretRef5;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type HostSecretRef2 = {
+    key: string;
+    name: string;
+};
+export type Host2 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: HostSecretRef2;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type PasswordSecretUriSecretRef = {
+    key: string;
+    name: string;
+};
+export type PasswordSecretUri = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: PasswordSecretUriSecretRef;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type PortSecretRef4 = {
+    key: string;
+    name: string;
+};
+export type Port4 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: PortSecretRef4;
+};
+/**
+ * Represents a value that can be either a concrete value, a template expression,
+ *
+ * @remarks
+ * or a reference to a Kubernetes Secret
+ */
+export type PortUnion4 = Port4 | number | any | string;
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type UsernameSecretRef4 = {
+    key: string;
+    name: string;
+};
+export type ExternalBindingUsername4 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: UsernameSecretRef4;
+};
+export declare const TypePostgres4: {
+    readonly Postgres: "postgres";
+};
+export type TypePostgres4 = ClosedEnum<typeof TypePostgres4>;
+/**
+ * Azure Flexible Server binding.
+ */
+export type ExternalBindingFlexibleServer = {
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    database: any | null;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    host: any | null;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    passwordSecretUri: any | null;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    port: Port4 | number | any | string | null;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    username: any | null;
+    service: "flexible-server";
+    type: TypePostgres4;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type DatabaseSecretRef4 = {
+    key: string;
+    name: string;
+};
+export type Database4 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: DatabaseSecretRef4;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type HostSecretRef1 = {
+    key: string;
+    name: string;
+};
+export type Host1 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: HostSecretRef1;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type PasswordSecretNameSecretRef = {
+    key: string;
+    name: string;
+};
+export type PasswordSecretName = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: PasswordSecretNameSecretRef;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type PortSecretRef3 = {
+    key: string;
+    name: string;
+};
+export type Port3 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: PortSecretRef3;
+};
+/**
+ * Represents a value that can be either a concrete value, a template expression,
+ *
+ * @remarks
+ * or a reference to a Kubernetes Secret
+ */
+export type PortUnion3 = Port3 | number | any | string;
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type ServerCaCertificatesSecretRef = {
+    key: string;
+    name: string;
+};
+export type ServerCaCertificates = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: ServerCaCertificatesSecretRef;
+};
+/**
+ * Represents a value that can be either a concrete value, a template expression,
+ *
+ * @remarks
+ * or a reference to a Kubernetes Secret
+ */
+export type ServerCaCertificatesUnion = ServerCaCertificates | Array<string> | any | string;
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type UsernameSecretRef3 = {
+    key: string;
+    name: string;
+};
+export type ExternalBindingUsername3 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: UsernameSecretRef3;
+};
+export declare const TypePostgres3: {
+    readonly Postgres: "postgres";
+};
+export type TypePostgres3 = ClosedEnum<typeof TypePostgres3>;
+/**
+ * GCP Cloud SQL binding.
+ */
+export type ExternalBindingCloudSQL = {
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    database: any | null;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    host: any | null;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    passwordSecretName: any | null;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    port: Port3 | number | any | string | null;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    serverCaCertificates: ServerCaCertificates | Array<string> | any | string | null;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    username: any | null;
+    service: "cloud-sql";
+    type: TypePostgres3;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type ClusterEndpointSecretRef2 = {
+    key: string;
+    name: string;
+};
+export type ClusterEndpoint2 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: ClusterEndpointSecretRef2;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type DatabaseSecretRef3 = {
+    key: string;
+    name: string;
+};
+export type Database3 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: DatabaseSecretRef3;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type PasswordSecretArnSecretRef2 = {
+    key: string;
+    name: string;
+};
+export type PasswordSecretArn2 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: PasswordSecretArnSecretRef2;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type PortSecretRef2 = {
+    key: string;
+    name: string;
+};
+export type Port2 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: PortSecretRef2;
+};
+/**
+ * Represents a value that can be either a concrete value, a template expression,
+ *
+ * @remarks
+ * or a reference to a Kubernetes Secret
+ */
+export type PortUnion2 = Port2 | number | any | string;
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type UsernameSecretRef2 = {
+    key: string;
+    name: string;
+};
+export type ExternalBindingUsername2 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: UsernameSecretRef2;
+};
+export declare const TypePostgres2: {
+    readonly Postgres: "postgres";
+};
+export type TypePostgres2 = ClosedEnum<typeof TypePostgres2>;
+/**
+ * AWS Aurora Serverless v2 binding.
+ */
+export type ExternalBindingAuroraManaged = {
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    clusterEndpoint: any | null;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    database: any | null;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    passwordSecretArn: any | null;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    port: Port2 | number | any | string | null;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    username: any | null;
+    service: "aurora-managed";
+    type: TypePostgres2;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type ClusterEndpointSecretRef1 = {
+    key: string;
+    name: string;
+};
+export type ClusterEndpoint1 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: ClusterEndpointSecretRef1;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type DatabaseSecretRef2 = {
+    key: string;
+    name: string;
+};
+export type Database2 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: DatabaseSecretRef2;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type PasswordSecretArnSecretRef1 = {
+    key: string;
+    name: string;
+};
+export type PasswordSecretArn1 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: PasswordSecretArnSecretRef1;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type PortSecretRef1 = {
+    key: string;
+    name: string;
+};
+export type Port1 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: PortSecretRef1;
+};
+/**
+ * Represents a value that can be either a concrete value, a template expression,
+ *
+ * @remarks
+ * or a reference to a Kubernetes Secret
+ */
+export type PortUnion1 = Port1 | number | any | string;
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type UsernameSecretRef1 = {
+    key: string;
+    name: string;
+};
+export type ExternalBindingUsername1 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: UsernameSecretRef1;
+};
+export declare const TypePostgres1: {
+    readonly Postgres: "postgres";
+};
+export type TypePostgres1 = ClosedEnum<typeof TypePostgres1>;
+/**
+ * AWS Aurora Serverless v2 binding.
+ */
+export type ExternalBindingAurora = {
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    clusterEndpoint: any | null;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    database: any | null;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    passwordSecretArn: any | null;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    port: Port1 | number | any | string | null;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    username: any | null;
+    service: "aurora";
+    type: TypePostgres1;
+};
+/**
+ * Connection details for a Postgres database, one variant per backend.
+ */
+export type ExternalBindingUnion6 = ExternalBindingAurora | ExternalBindingAuroraManaged | ExternalBindingCloudSQL | ExternalBindingFlexibleServer | ExternalBindingExternal | ExternalBindingLocalPostgres;
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type DefaultDomainSecretRef = {
+    key: string;
+    name: string;
+};
+export type DefaultDomain = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: DefaultDomainSecretRef;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type EnvironmentNameSecretRef = {
+    key: string;
+    name: string;
+};
+export type EnvironmentName = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: EnvironmentNameSecretRef;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type ResourceGroupNameSecretRef3 = {
+    key: string;
+    name: string;
+};
+export type ResourceGroupName3 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: ResourceGroupNameSecretRef3;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type ResourceIdSecretRef = {
+    key: string;
+    name: string;
+};
+export type ResourceId = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: ResourceIdSecretRef;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type StaticIpSecretRef = {
+    key: string;
+    name: string;
+};
+export type StaticIp = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: StaticIpSecretRef;
+};
+export declare const TypeContainerAppsEnvironment: {
+    readonly ContainerAppsEnvironment: "container_apps_environment";
+};
+export type TypeContainerAppsEnvironment = ClosedEnum<typeof TypeContainerAppsEnvironment>;
+/**
+ * Binding configuration for a pre-existing Azure Container Apps Environment.
+ *
+ * @remarks
+ *
+ * Used when deploying to an existing environment instead of having Alien provision one.
+ * This is useful for shared environments (e.g., test infrastructure) or enterprise
+ * setups where environments are managed by a separate team.
+ */
+export type ExternalBindingContainerAppsEnvironment = {
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    defaultDomain: any | null;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    environmentName: any | null;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    resourceGroupName: any | null;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    resourceId: any | null;
+    staticIp?: any | null | undefined;
+    type: TypeContainerAppsEnvironment;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type DataDirSecretRef3 = {
+    key: string;
+    name: string;
+};
+export type DataDir3 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: DataDirSecretRef3;
+};
+export declare const TypeVault5: {
+    readonly Vault: "vault";
+};
+export type TypeVault5 = ClosedEnum<typeof TypeVault5>;
+/**
+ * Local development vault binding (for testing/development)
+ */
+export type ExternalBindingLocalVault = {
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    dataDir: any | null;
+    /**
+     * The vault name for local storage
+     */
+    vaultName: string;
+    service: "local-vault";
+    type: TypeVault5;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type NamespaceSecretRef2 = {
+    key: string;
+    name: string;
+};
+export type Namespace2 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: NamespaceSecretRef2;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type VaultPrefixSecretRef3 = {
+    key: string;
+    name: string;
+};
+export type VaultPrefix3 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: VaultPrefixSecretRef3;
+};
+export declare const TypeVault4: {
+    readonly Vault: "vault";
+};
+export type TypeVault4 = ClosedEnum<typeof TypeVault4>;
+/**
+ * Kubernetes Secrets vault binding configuration
+ */
+export type ExternalBindingKubernetesSecret = {
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    namespace: any | null;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    vaultPrefix: any | null;
+    service: "kubernetes-secret";
+    type: TypeVault4;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type VaultNameSecretRef = {
+    key: string;
+    name: string;
+};
+export type VaultName = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: VaultNameSecretRef;
+};
+export declare const TypeVault3: {
+    readonly Vault: "vault";
+};
+export type TypeVault3 = ClosedEnum<typeof TypeVault3>;
+/**
+ * Azure Key Vault binding configuration
+ */
+export type ExternalBindingKeyVault = {
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    vaultName: any | null;
+    service: "key-vault";
+    type: TypeVault3;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type VaultPrefixSecretRef2 = {
+    key: string;
+    name: string;
+};
+export type VaultPrefix2 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: VaultPrefixSecretRef2;
+};
+export declare const TypeVault2: {
+    readonly Vault: "vault";
+};
+export type TypeVault2 = ClosedEnum<typeof TypeVault2>;
+/**
+ * GCP Secret Manager vault binding configuration
+ */
+export type ExternalBindingSecretManager = {
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    vaultPrefix: any | null;
+    service: "secret-manager";
+    type: TypeVault2;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type VaultPrefixSecretRef1 = {
+    key: string;
+    name: string;
+};
+export type VaultPrefix1 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: VaultPrefixSecretRef1;
+};
+export declare const TypeVault1: {
+    readonly Vault: "vault";
+};
+export type TypeVault1 = ClosedEnum<typeof TypeVault1>;
+/**
+ * AWS SSM Parameter Store vault binding configuration
+ */
+export type ExternalBindingParameterStore = {
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    vaultPrefix: any | null;
+    service: "parameter-store";
+    type: TypeVault1;
+};
+/**
+ * Represents a vault binding for secure secret management
+ */
+export type ExternalBindingUnion5 = ExternalBindingParameterStore | ExternalBindingSecretManager | ExternalBindingKeyVault | ExternalBindingKubernetesSecret | ExternalBindingLocalVault;
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type DataDirSecretRef2 = {
+    key: string;
+    name: string;
+};
+export type DataDir2 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: DataDirSecretRef2;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type RegistryUrlSecretRef = {
+    key: string;
+    name: string;
+};
+export type RegistryUrl = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: RegistryUrlSecretRef;
+};
+export declare const TypeArtifactRegistry4: {
+    readonly ArtifactRegistry: "artifact_registry";
+};
+export type TypeArtifactRegistry4 = ClosedEnum<typeof TypeArtifactRegistry4>;
+/**
+ * Local container registry binding configuration.
+ *
+ * @remarks
+ *
+ * The local registry runs on localhost only and does not require authentication.
+ * Security boundary is the OS process isolation on the customer's machine.
+ * External image access is secured by the manager's registry proxy (deployment tokens).
+ */
+export type ExternalBindingLocal = {
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    dataDir: any | null;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    registryUrl: any | null;
+    service: "local";
+    type: TypeArtifactRegistry4;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type PullServiceAccountEmailSecretRef = {
+    key: string;
+    name: string;
+};
+export type PullServiceAccountEmail = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: PullServiceAccountEmailSecretRef;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type PushServiceAccountEmailSecretRef = {
+    key: string;
+    name: string;
+};
+export type PushServiceAccountEmail = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: PushServiceAccountEmailSecretRef;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type RepositoryNameSecretRef = {
+    key: string;
+    name: string;
+};
+export type RepositoryName = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: RepositoryNameSecretRef;
+};
+export declare const TypeArtifactRegistry3: {
+    readonly ArtifactRegistry: "artifact_registry";
+};
+export type TypeArtifactRegistry3 = ClosedEnum<typeof TypeArtifactRegistry3>;
+/**
+ * Google Artifact Registry binding configuration
+ */
+export type ExternalBindingGar = {
+    pullServiceAccountEmail?: any | null | undefined;
+    pushServiceAccountEmail?: any | null | undefined;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    repositoryName: any | null;
+    service: "gar";
+    type: TypeArtifactRegistry3;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type RegistryNameSecretRef = {
+    key: string;
+    name: string;
+};
+export type RegistryName = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: RegistryNameSecretRef;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type RepositoryPrefixSecretRef2 = {
+    key: string;
+    name: string;
+};
+export type RepositoryPrefix2 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: RepositoryPrefixSecretRef2;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type ResourceGroupNameSecretRef2 = {
+    key: string;
+    name: string;
+};
+export type ResourceGroupName2 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: ResourceGroupNameSecretRef2;
+};
+export declare const TypeArtifactRegistry2: {
+    readonly ArtifactRegistry: "artifact_registry";
+};
+export type TypeArtifactRegistry2 = ClosedEnum<typeof TypeArtifactRegistry2>;
+/**
+ * Azure Container Registry binding configuration
+ */
+export type ExternalBindingAcr = {
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    registryName: any | null;
+    repositoryPrefix?: any | null | undefined;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    resourceGroupName: any | null;
+    service: "acr";
+    type: TypeArtifactRegistry2;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type PullRoleArnSecretRef = {
+    key: string;
+    name: string;
+};
+export type PullRoleArn = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: PullRoleArnSecretRef;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type PushRoleArnSecretRef = {
+    key: string;
+    name: string;
+};
+export type PushRoleArn = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: PushRoleArnSecretRef;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type RepositoryPrefixSecretRef1 = {
+    key: string;
+    name: string;
+};
+export type RepositoryPrefix1 = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: RepositoryPrefixSecretRef1;
+};
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type SandboxRepositoryPrefixSecretRef = {
+    key: string;
+    name: string;
+};
+export type SandboxRepositoryPrefix = {
+    /**
+     * Reference to a Kubernetes Secret
+     */
+    secretRef: SandboxRepositoryPrefixSecretRef;
+};
+export declare const TypeArtifactRegistry1: {
+    readonly ArtifactRegistry: "artifact_registry";
+};
+export type TypeArtifactRegistry1 = ClosedEnum<typeof TypeArtifactRegistry1>;
+/**
+ * AWS ECR (Elastic Container Registry) binding configuration
+ */
+export type ExternalBindingEcr = {
+    /**
+     * Repository prefixes this registry used before `repositoryPrefix`. Images already released
+     *
+     * @remarks
+     * under them stay readable and keep their cross-account grants; nothing new is written there.
+     */
+    legacyRepositoryPrefixes?: Array<string> | undefined;
+    /**
+     * Sandbox namespaces this registry used before `sandboxRepositoryPrefix`, read the same way.
+     */
+    legacySandboxRepositoryPrefixes?: Array<string> | undefined;
+    pullRoleArn?: any | null | undefined;
+    pushRoleArn?: any | null | undefined;
+    /**
+     * Represents a value that can be either a concrete value, a template expression,
+     *
+     * @remarks
+     * or a reference to a Kubernetes Secret
+     */
+    repositoryPrefix: any | null;
+    sandboxRepositoryPrefix?: any | null | undefined;
+    service: "ecr";
+    type: TypeArtifactRegistry1;
+};
+/** @internal */
+export declare const ApiKeySecretRef$inboundSchema: z.ZodType<ApiKeySecretRef, unknown>;
+/** @internal */
+export type ApiKeySecretRef$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const ApiKeySecretRef$outboundSchema: z.ZodType<ApiKeySecretRef$Outbound, ApiKeySecretRef>;
+export declare function apiKeySecretRefToJSON(apiKeySecretRef: ApiKeySecretRef): string;
+export declare function apiKeySecretRefFromJSON(jsonString: string): SafeParseResult<ApiKeySecretRef, SDKValidationError>;
+/** @internal */
+export declare const ExternalBindingApiKey$inboundSchema: z.ZodType<ExternalBindingApiKey, unknown>;
+/** @internal */
+export type ExternalBindingApiKey$Outbound = {
+    secretRef: ApiKeySecretRef$Outbound;
+};
+/** @internal */
+export declare const ExternalBindingApiKey$outboundSchema: z.ZodType<ExternalBindingApiKey$Outbound, ExternalBindingApiKey>;
+export declare function externalBindingApiKeyToJSON(externalBindingApiKey: ExternalBindingApiKey): string;
+export declare function externalBindingApiKeyFromJSON(jsonString: string): SafeParseResult<ExternalBindingApiKey, SDKValidationError>;
+/** @internal */
+export declare const TypeAi$inboundSchema: z.ZodEnum<typeof TypeAi>;
+/** @internal */
+export declare const TypeAi$outboundSchema: z.ZodEnum<typeof TypeAi>;
+/** @internal */
+export declare const ExternalBindingAi$inboundSchema: z.ZodType<ExternalBindingAi, unknown>;
+/** @internal */
+export type ExternalBindingAi$Outbound = {
+    apiKey: any | null;
+    provider: string;
+    type: string;
+};
+/** @internal */
+export declare const ExternalBindingAi$outboundSchema: z.ZodType<ExternalBindingAi$Outbound, ExternalBindingAi>;
+export declare function externalBindingAiToJSON(externalBindingAi: ExternalBindingAi): string;
+export declare function externalBindingAiFromJSON(jsonString: string): SafeParseResult<ExternalBindingAi, SDKValidationError>;
+/** @internal */
+export declare const DatabaseSecretRef7$inboundSchema: z.ZodType<DatabaseSecretRef7, unknown>;
+/** @internal */
+export type DatabaseSecretRef7$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const DatabaseSecretRef7$outboundSchema: z.ZodType<DatabaseSecretRef7$Outbound, DatabaseSecretRef7>;
+export declare function databaseSecretRef7ToJSON(databaseSecretRef7: DatabaseSecretRef7): string;
+export declare function databaseSecretRef7FromJSON(jsonString: string): SafeParseResult<DatabaseSecretRef7, SDKValidationError>;
+/** @internal */
+export declare const Database7$inboundSchema: z.ZodType<Database7, unknown>;
+/** @internal */
+export type Database7$Outbound = {
+    secretRef: DatabaseSecretRef7$Outbound;
+};
+/** @internal */
+export declare const Database7$outboundSchema: z.ZodType<Database7$Outbound, Database7>;
+export declare function database7ToJSON(database7: Database7): string;
+export declare function database7FromJSON(jsonString: string): SafeParseResult<Database7, SDKValidationError>;
+/** @internal */
+export declare const HostSecretRef4$inboundSchema: z.ZodType<HostSecretRef4, unknown>;
+/** @internal */
+export type HostSecretRef4$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const HostSecretRef4$outboundSchema: z.ZodType<HostSecretRef4$Outbound, HostSecretRef4>;
+export declare function hostSecretRef4ToJSON(hostSecretRef4: HostSecretRef4): string;
+export declare function hostSecretRef4FromJSON(jsonString: string): SafeParseResult<HostSecretRef4, SDKValidationError>;
+/** @internal */
+export declare const Host4$inboundSchema: z.ZodType<Host4, unknown>;
+/** @internal */
+export type Host4$Outbound = {
+    secretRef: HostSecretRef4$Outbound;
+};
+/** @internal */
+export declare const Host4$outboundSchema: z.ZodType<Host4$Outbound, Host4>;
+export declare function host4ToJSON(host4: Host4): string;
+export declare function host4FromJSON(jsonString: string): SafeParseResult<Host4, SDKValidationError>;
+/** @internal */
+export declare const PortSecretRef6$inboundSchema: z.ZodType<PortSecretRef6, unknown>;
+/** @internal */
+export type PortSecretRef6$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const PortSecretRef6$outboundSchema: z.ZodType<PortSecretRef6$Outbound, PortSecretRef6>;
+export declare function portSecretRef6ToJSON(portSecretRef6: PortSecretRef6): string;
+export declare function portSecretRef6FromJSON(jsonString: string): SafeParseResult<PortSecretRef6, SDKValidationError>;
+/** @internal */
+export declare const Port6$inboundSchema: z.ZodType<Port6, unknown>;
+/** @internal */
+export type Port6$Outbound = {
+    secretRef: PortSecretRef6$Outbound;
+};
+/** @internal */
+export declare const Port6$outboundSchema: z.ZodType<Port6$Outbound, Port6>;
+export declare function port6ToJSON(port6: Port6): string;
+export declare function port6FromJSON(jsonString: string): SafeParseResult<Port6, SDKValidationError>;
+/** @internal */
+export declare const PortUnion6$inboundSchema: z.ZodType<PortUnion6, unknown>;
+/** @internal */
+export type PortUnion6$Outbound = Port6$Outbound | number | any | string;
+/** @internal */
+export declare const PortUnion6$outboundSchema: z.ZodType<PortUnion6$Outbound, PortUnion6>;
+export declare function portUnion6ToJSON(portUnion6: PortUnion6): string;
+export declare function portUnion6FromJSON(jsonString: string): SafeParseResult<PortUnion6, SDKValidationError>;
+/** @internal */
+export declare const UsernameSecretRef6$inboundSchema: z.ZodType<UsernameSecretRef6, unknown>;
+/** @internal */
+export type UsernameSecretRef6$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const UsernameSecretRef6$outboundSchema: z.ZodType<UsernameSecretRef6$Outbound, UsernameSecretRef6>;
+export declare function usernameSecretRef6ToJSON(usernameSecretRef6: UsernameSecretRef6): string;
+export declare function usernameSecretRef6FromJSON(jsonString: string): SafeParseResult<UsernameSecretRef6, SDKValidationError>;
+/** @internal */
+export declare const ExternalBindingUsername6$inboundSchema: z.ZodType<ExternalBindingUsername6, unknown>;
+/** @internal */
+export type ExternalBindingUsername6$Outbound = {
+    secretRef: UsernameSecretRef6$Outbound;
+};
+/** @internal */
+export declare const ExternalBindingUsername6$outboundSchema: z.ZodType<ExternalBindingUsername6$Outbound, ExternalBindingUsername6>;
+export declare function externalBindingUsername6ToJSON(externalBindingUsername6: ExternalBindingUsername6): string;
+export declare function externalBindingUsername6FromJSON(jsonString: string): SafeParseResult<ExternalBindingUsername6, SDKValidationError>;
+/** @internal */
+export declare const TypePostgres6$inboundSchema: z.ZodEnum<typeof TypePostgres6>;
+/** @internal */
+export declare const TypePostgres6$outboundSchema: z.ZodEnum<typeof TypePostgres6>;
+/** @internal */
+export declare const ExternalBindingLocalPostgres$inboundSchema: z.ZodType<ExternalBindingLocalPostgres, unknown>;
+/** @internal */
+export type ExternalBindingLocalPostgres$Outbound = {
+    database: any | null;
+    host: any | null;
+    password: string;
+    port: Port6$Outbound | number | any | string | null;
+    username: any | null;
+    service: "local-postgres";
+    type: string;
+};
+/** @internal */
+export declare const ExternalBindingLocalPostgres$outboundSchema: z.ZodType<ExternalBindingLocalPostgres$Outbound, ExternalBindingLocalPostgres>;
+export declare function externalBindingLocalPostgresToJSON(externalBindingLocalPostgres: ExternalBindingLocalPostgres): string;
+export declare function externalBindingLocalPostgresFromJSON(jsonString: string): SafeParseResult<ExternalBindingLocalPostgres, SDKValidationError>;
+/** @internal */
+export declare const DatabaseSecretRef6$inboundSchema: z.ZodType<DatabaseSecretRef6, unknown>;
+/** @internal */
+export type DatabaseSecretRef6$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const DatabaseSecretRef6$outboundSchema: z.ZodType<DatabaseSecretRef6$Outbound, DatabaseSecretRef6>;
+export declare function databaseSecretRef6ToJSON(databaseSecretRef6: DatabaseSecretRef6): string;
+export declare function databaseSecretRef6FromJSON(jsonString: string): SafeParseResult<DatabaseSecretRef6, SDKValidationError>;
+/** @internal */
+export declare const Database6$inboundSchema: z.ZodType<Database6, unknown>;
+/** @internal */
+export type Database6$Outbound = {
+    secretRef: DatabaseSecretRef6$Outbound;
+};
+/** @internal */
+export declare const Database6$outboundSchema: z.ZodType<Database6$Outbound, Database6>;
+export declare function database6ToJSON(database6: Database6): string;
+export declare function database6FromJSON(jsonString: string): SafeParseResult<Database6, SDKValidationError>;
+/** @internal */
+export declare const HostSecretRef3$inboundSchema: z.ZodType<HostSecretRef3, unknown>;
+/** @internal */
+export type HostSecretRef3$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const HostSecretRef3$outboundSchema: z.ZodType<HostSecretRef3$Outbound, HostSecretRef3>;
+export declare function hostSecretRef3ToJSON(hostSecretRef3: HostSecretRef3): string;
+export declare function hostSecretRef3FromJSON(jsonString: string): SafeParseResult<HostSecretRef3, SDKValidationError>;
+/** @internal */
+export declare const Host3$inboundSchema: z.ZodType<Host3, unknown>;
+/** @internal */
+export type Host3$Outbound = {
+    secretRef: HostSecretRef3$Outbound;
+};
+/** @internal */
+export declare const Host3$outboundSchema: z.ZodType<Host3$Outbound, Host3>;
+export declare function host3ToJSON(host3: Host3): string;
+export declare function host3FromJSON(jsonString: string): SafeParseResult<Host3, SDKValidationError>;
+/** @internal */
+export declare const PortSecretRef5$inboundSchema: z.ZodType<PortSecretRef5, unknown>;
+/** @internal */
+export type PortSecretRef5$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const PortSecretRef5$outboundSchema: z.ZodType<PortSecretRef5$Outbound, PortSecretRef5>;
+export declare function portSecretRef5ToJSON(portSecretRef5: PortSecretRef5): string;
+export declare function portSecretRef5FromJSON(jsonString: string): SafeParseResult<PortSecretRef5, SDKValidationError>;
+/** @internal */
+export declare const Port5$inboundSchema: z.ZodType<Port5, unknown>;
+/** @internal */
+export type Port5$Outbound = {
+    secretRef: PortSecretRef5$Outbound;
+};
+/** @internal */
+export declare const Port5$outboundSchema: z.ZodType<Port5$Outbound, Port5>;
+export declare function port5ToJSON(port5: Port5): string;
+export declare function port5FromJSON(jsonString: string): SafeParseResult<Port5, SDKValidationError>;
+/** @internal */
+export declare const PortUnion5$inboundSchema: z.ZodType<PortUnion5, unknown>;
+/** @internal */
+export type PortUnion5$Outbound = Port5$Outbound | number | any | string;
+/** @internal */
+export declare const PortUnion5$outboundSchema: z.ZodType<PortUnion5$Outbound, PortUnion5>;
+export declare function portUnion5ToJSON(portUnion5: PortUnion5): string;
+export declare function portUnion5FromJSON(jsonString: string): SafeParseResult<PortUnion5, SDKValidationError>;
+/** @internal */
+export declare const SslMode$inboundSchema: z.ZodEnum<typeof SslMode>;
+/** @internal */
+export declare const SslMode$outboundSchema: z.ZodEnum<typeof SslMode>;
+/** @internal */
+export declare const UsernameSecretRef5$inboundSchema: z.ZodType<UsernameSecretRef5, unknown>;
+/** @internal */
+export type UsernameSecretRef5$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const UsernameSecretRef5$outboundSchema: z.ZodType<UsernameSecretRef5$Outbound, UsernameSecretRef5>;
+export declare function usernameSecretRef5ToJSON(usernameSecretRef5: UsernameSecretRef5): string;
+export declare function usernameSecretRef5FromJSON(jsonString: string): SafeParseResult<UsernameSecretRef5, SDKValidationError>;
+/** @internal */
+export declare const ExternalBindingUsername5$inboundSchema: z.ZodType<ExternalBindingUsername5, unknown>;
+/** @internal */
+export type ExternalBindingUsername5$Outbound = {
+    secretRef: UsernameSecretRef5$Outbound;
+};
+/** @internal */
+export declare const ExternalBindingUsername5$outboundSchema: z.ZodType<ExternalBindingUsername5$Outbound, ExternalBindingUsername5>;
+export declare function externalBindingUsername5ToJSON(externalBindingUsername5: ExternalBindingUsername5): string;
+export declare function externalBindingUsername5FromJSON(jsonString: string): SafeParseResult<ExternalBindingUsername5, SDKValidationError>;
+/** @internal */
+export declare const TypePostgres5$inboundSchema: z.ZodEnum<typeof TypePostgres5>;
+/** @internal */
+export declare const TypePostgres5$outboundSchema: z.ZodEnum<typeof TypePostgres5>;
+/** @internal */
+export declare const ExternalBindingExternal$inboundSchema: z.ZodType<ExternalBindingExternal, unknown>;
+/** @internal */
+export type ExternalBindingExternal$Outbound = {
+    database: any | null;
+    host: any | null;
+    password: string;
+    port: Port5$Outbound | number | any | string | null;
+    sslMode?: string | undefined;
+    username: any | null;
+    service: "external";
+    type: string;
+};
+/** @internal */
+export declare const ExternalBindingExternal$outboundSchema: z.ZodType<ExternalBindingExternal$Outbound, ExternalBindingExternal>;
+export declare function externalBindingExternalToJSON(externalBindingExternal: ExternalBindingExternal): string;
+export declare function externalBindingExternalFromJSON(jsonString: string): SafeParseResult<ExternalBindingExternal, SDKValidationError>;
+/** @internal */
+export declare const DatabaseSecretRef5$inboundSchema: z.ZodType<DatabaseSecretRef5, unknown>;
+/** @internal */
+export type DatabaseSecretRef5$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const DatabaseSecretRef5$outboundSchema: z.ZodType<DatabaseSecretRef5$Outbound, DatabaseSecretRef5>;
+export declare function databaseSecretRef5ToJSON(databaseSecretRef5: DatabaseSecretRef5): string;
+export declare function databaseSecretRef5FromJSON(jsonString: string): SafeParseResult<DatabaseSecretRef5, SDKValidationError>;
+/** @internal */
+export declare const Database5$inboundSchema: z.ZodType<Database5, unknown>;
+/** @internal */
+export type Database5$Outbound = {
+    secretRef: DatabaseSecretRef5$Outbound;
+};
+/** @internal */
+export declare const Database5$outboundSchema: z.ZodType<Database5$Outbound, Database5>;
+export declare function database5ToJSON(database5: Database5): string;
+export declare function database5FromJSON(jsonString: string): SafeParseResult<Database5, SDKValidationError>;
+/** @internal */
+export declare const HostSecretRef2$inboundSchema: z.ZodType<HostSecretRef2, unknown>;
+/** @internal */
+export type HostSecretRef2$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const HostSecretRef2$outboundSchema: z.ZodType<HostSecretRef2$Outbound, HostSecretRef2>;
+export declare function hostSecretRef2ToJSON(hostSecretRef2: HostSecretRef2): string;
+export declare function hostSecretRef2FromJSON(jsonString: string): SafeParseResult<HostSecretRef2, SDKValidationError>;
+/** @internal */
+export declare const Host2$inboundSchema: z.ZodType<Host2, unknown>;
+/** @internal */
+export type Host2$Outbound = {
+    secretRef: HostSecretRef2$Outbound;
+};
+/** @internal */
+export declare const Host2$outboundSchema: z.ZodType<Host2$Outbound, Host2>;
+export declare function host2ToJSON(host2: Host2): string;
+export declare function host2FromJSON(jsonString: string): SafeParseResult<Host2, SDKValidationError>;
+/** @internal */
+export declare const PasswordSecretUriSecretRef$inboundSchema: z.ZodType<PasswordSecretUriSecretRef, unknown>;
+/** @internal */
+export type PasswordSecretUriSecretRef$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const PasswordSecretUriSecretRef$outboundSchema: z.ZodType<PasswordSecretUriSecretRef$Outbound, PasswordSecretUriSecretRef>;
+export declare function passwordSecretUriSecretRefToJSON(passwordSecretUriSecretRef: PasswordSecretUriSecretRef): string;
+export declare function passwordSecretUriSecretRefFromJSON(jsonString: string): SafeParseResult<PasswordSecretUriSecretRef, SDKValidationError>;
+/** @internal */
+export declare const PasswordSecretUri$inboundSchema: z.ZodType<PasswordSecretUri, unknown>;
+/** @internal */
+export type PasswordSecretUri$Outbound = {
+    secretRef: PasswordSecretUriSecretRef$Outbound;
+};
+/** @internal */
+export declare const PasswordSecretUri$outboundSchema: z.ZodType<PasswordSecretUri$Outbound, PasswordSecretUri>;
+export declare function passwordSecretUriToJSON(passwordSecretUri: PasswordSecretUri): string;
+export declare function passwordSecretUriFromJSON(jsonString: string): SafeParseResult<PasswordSecretUri, SDKValidationError>;
+/** @internal */
+export declare const PortSecretRef4$inboundSchema: z.ZodType<PortSecretRef4, unknown>;
+/** @internal */
+export type PortSecretRef4$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const PortSecretRef4$outboundSchema: z.ZodType<PortSecretRef4$Outbound, PortSecretRef4>;
+export declare function portSecretRef4ToJSON(portSecretRef4: PortSecretRef4): string;
+export declare function portSecretRef4FromJSON(jsonString: string): SafeParseResult<PortSecretRef4, SDKValidationError>;
+/** @internal */
+export declare const Port4$inboundSchema: z.ZodType<Port4, unknown>;
+/** @internal */
+export type Port4$Outbound = {
+    secretRef: PortSecretRef4$Outbound;
+};
+/** @internal */
+export declare const Port4$outboundSchema: z.ZodType<Port4$Outbound, Port4>;
+export declare function port4ToJSON(port4: Port4): string;
+export declare function port4FromJSON(jsonString: string): SafeParseResult<Port4, SDKValidationError>;
+/** @internal */
+export declare const PortUnion4$inboundSchema: z.ZodType<PortUnion4, unknown>;
+/** @internal */
+export type PortUnion4$Outbound = Port4$Outbound | number | any | string;
+/** @internal */
+export declare const PortUnion4$outboundSchema: z.ZodType<PortUnion4$Outbound, PortUnion4>;
+export declare function portUnion4ToJSON(portUnion4: PortUnion4): string;
+export declare function portUnion4FromJSON(jsonString: string): SafeParseResult<PortUnion4, SDKValidationError>;
+/** @internal */
+export declare const UsernameSecretRef4$inboundSchema: z.ZodType<UsernameSecretRef4, unknown>;
+/** @internal */
+export type UsernameSecretRef4$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const UsernameSecretRef4$outboundSchema: z.ZodType<UsernameSecretRef4$Outbound, UsernameSecretRef4>;
+export declare function usernameSecretRef4ToJSON(usernameSecretRef4: UsernameSecretRef4): string;
+export declare function usernameSecretRef4FromJSON(jsonString: string): SafeParseResult<UsernameSecretRef4, SDKValidationError>;
+/** @internal */
+export declare const ExternalBindingUsername4$inboundSchema: z.ZodType<ExternalBindingUsername4, unknown>;
+/** @internal */
+export type ExternalBindingUsername4$Outbound = {
+    secretRef: UsernameSecretRef4$Outbound;
+};
+/** @internal */
+export declare const ExternalBindingUsername4$outboundSchema: z.ZodType<ExternalBindingUsername4$Outbound, ExternalBindingUsername4>;
+export declare function externalBindingUsername4ToJSON(externalBindingUsername4: ExternalBindingUsername4): string;
+export declare function externalBindingUsername4FromJSON(jsonString: string): SafeParseResult<ExternalBindingUsername4, SDKValidationError>;
+/** @internal */
+export declare const TypePostgres4$inboundSchema: z.ZodEnum<typeof TypePostgres4>;
+/** @internal */
+export declare const TypePostgres4$outboundSchema: z.ZodEnum<typeof TypePostgres4>;
+/** @internal */
+export declare const ExternalBindingFlexibleServer$inboundSchema: z.ZodType<ExternalBindingFlexibleServer, unknown>;
+/** @internal */
+export type ExternalBindingFlexibleServer$Outbound = {
+    database: any | null;
+    host: any | null;
+    passwordSecretUri: any | null;
+    port: Port4$Outbound | number | any | string | null;
+    username: any | null;
+    service: "flexible-server";
+    type: string;
+};
+/** @internal */
+export declare const ExternalBindingFlexibleServer$outboundSchema: z.ZodType<ExternalBindingFlexibleServer$Outbound, ExternalBindingFlexibleServer>;
+export declare function externalBindingFlexibleServerToJSON(externalBindingFlexibleServer: ExternalBindingFlexibleServer): string;
+export declare function externalBindingFlexibleServerFromJSON(jsonString: string): SafeParseResult<ExternalBindingFlexibleServer, SDKValidationError>;
+/** @internal */
+export declare const DatabaseSecretRef4$inboundSchema: z.ZodType<DatabaseSecretRef4, unknown>;
+/** @internal */
+export type DatabaseSecretRef4$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const DatabaseSecretRef4$outboundSchema: z.ZodType<DatabaseSecretRef4$Outbound, DatabaseSecretRef4>;
+export declare function databaseSecretRef4ToJSON(databaseSecretRef4: DatabaseSecretRef4): string;
+export declare function databaseSecretRef4FromJSON(jsonString: string): SafeParseResult<DatabaseSecretRef4, SDKValidationError>;
+/** @internal */
+export declare const Database4$inboundSchema: z.ZodType<Database4, unknown>;
+/** @internal */
+export type Database4$Outbound = {
+    secretRef: DatabaseSecretRef4$Outbound;
+};
+/** @internal */
+export declare const Database4$outboundSchema: z.ZodType<Database4$Outbound, Database4>;
+export declare function database4ToJSON(database4: Database4): string;
+export declare function database4FromJSON(jsonString: string): SafeParseResult<Database4, SDKValidationError>;
+/** @internal */
+export declare const HostSecretRef1$inboundSchema: z.ZodType<HostSecretRef1, unknown>;
+/** @internal */
+export type HostSecretRef1$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const HostSecretRef1$outboundSchema: z.ZodType<HostSecretRef1$Outbound, HostSecretRef1>;
+export declare function hostSecretRef1ToJSON(hostSecretRef1: HostSecretRef1): string;
+export declare function hostSecretRef1FromJSON(jsonString: string): SafeParseResult<HostSecretRef1, SDKValidationError>;
+/** @internal */
+export declare const Host1$inboundSchema: z.ZodType<Host1, unknown>;
+/** @internal */
+export type Host1$Outbound = {
+    secretRef: HostSecretRef1$Outbound;
+};
+/** @internal */
+export declare const Host1$outboundSchema: z.ZodType<Host1$Outbound, Host1>;
+export declare function host1ToJSON(host1: Host1): string;
+export declare function host1FromJSON(jsonString: string): SafeParseResult<Host1, SDKValidationError>;
+/** @internal */
+export declare const PasswordSecretNameSecretRef$inboundSchema: z.ZodType<PasswordSecretNameSecretRef, unknown>;
+/** @internal */
+export type PasswordSecretNameSecretRef$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const PasswordSecretNameSecretRef$outboundSchema: z.ZodType<PasswordSecretNameSecretRef$Outbound, PasswordSecretNameSecretRef>;
+export declare function passwordSecretNameSecretRefToJSON(passwordSecretNameSecretRef: PasswordSecretNameSecretRef): string;
+export declare function passwordSecretNameSecretRefFromJSON(jsonString: string): SafeParseResult<PasswordSecretNameSecretRef, SDKValidationError>;
+/** @internal */
+export declare const PasswordSecretName$inboundSchema: z.ZodType<PasswordSecretName, unknown>;
+/** @internal */
+export type PasswordSecretName$Outbound = {
+    secretRef: PasswordSecretNameSecretRef$Outbound;
+};
+/** @internal */
+export declare const PasswordSecretName$outboundSchema: z.ZodType<PasswordSecretName$Outbound, PasswordSecretName>;
+export declare function passwordSecretNameToJSON(passwordSecretName: PasswordSecretName): string;
+export declare function passwordSecretNameFromJSON(jsonString: string): SafeParseResult<PasswordSecretName, SDKValidationError>;
+/** @internal */
+export declare const PortSecretRef3$inboundSchema: z.ZodType<PortSecretRef3, unknown>;
+/** @internal */
+export type PortSecretRef3$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const PortSecretRef3$outboundSchema: z.ZodType<PortSecretRef3$Outbound, PortSecretRef3>;
+export declare function portSecretRef3ToJSON(portSecretRef3: PortSecretRef3): string;
+export declare function portSecretRef3FromJSON(jsonString: string): SafeParseResult<PortSecretRef3, SDKValidationError>;
+/** @internal */
+export declare const Port3$inboundSchema: z.ZodType<Port3, unknown>;
+/** @internal */
+export type Port3$Outbound = {
+    secretRef: PortSecretRef3$Outbound;
+};
+/** @internal */
+export declare const Port3$outboundSchema: z.ZodType<Port3$Outbound, Port3>;
+export declare function port3ToJSON(port3: Port3): string;
+export declare function port3FromJSON(jsonString: string): SafeParseResult<Port3, SDKValidationError>;
+/** @internal */
+export declare const PortUnion3$inboundSchema: z.ZodType<PortUnion3, unknown>;
+/** @internal */
+export type PortUnion3$Outbound = Port3$Outbound | number | any | string;
+/** @internal */
+export declare const PortUnion3$outboundSchema: z.ZodType<PortUnion3$Outbound, PortUnion3>;
+export declare function portUnion3ToJSON(portUnion3: PortUnion3): string;
+export declare function portUnion3FromJSON(jsonString: string): SafeParseResult<PortUnion3, SDKValidationError>;
+/** @internal */
+export declare const ServerCaCertificatesSecretRef$inboundSchema: z.ZodType<ServerCaCertificatesSecretRef, unknown>;
+/** @internal */
+export type ServerCaCertificatesSecretRef$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const ServerCaCertificatesSecretRef$outboundSchema: z.ZodType<ServerCaCertificatesSecretRef$Outbound, ServerCaCertificatesSecretRef>;
+export declare function serverCaCertificatesSecretRefToJSON(serverCaCertificatesSecretRef: ServerCaCertificatesSecretRef): string;
+export declare function serverCaCertificatesSecretRefFromJSON(jsonString: string): SafeParseResult<ServerCaCertificatesSecretRef, SDKValidationError>;
+/** @internal */
+export declare const ServerCaCertificates$inboundSchema: z.ZodType<ServerCaCertificates, unknown>;
+/** @internal */
+export type ServerCaCertificates$Outbound = {
+    secretRef: ServerCaCertificatesSecretRef$Outbound;
+};
+/** @internal */
+export declare const ServerCaCertificates$outboundSchema: z.ZodType<ServerCaCertificates$Outbound, ServerCaCertificates>;
+export declare function serverCaCertificatesToJSON(serverCaCertificates: ServerCaCertificates): string;
+export declare function serverCaCertificatesFromJSON(jsonString: string): SafeParseResult<ServerCaCertificates, SDKValidationError>;
+/** @internal */
+export declare const ServerCaCertificatesUnion$inboundSchema: z.ZodType<ServerCaCertificatesUnion, unknown>;
+/** @internal */
+export type ServerCaCertificatesUnion$Outbound = ServerCaCertificates$Outbound | Array<string> | any | string;
+/** @internal */
+export declare const ServerCaCertificatesUnion$outboundSchema: z.ZodType<ServerCaCertificatesUnion$Outbound, ServerCaCertificatesUnion>;
+export declare function serverCaCertificatesUnionToJSON(serverCaCertificatesUnion: ServerCaCertificatesUnion): string;
+export declare function serverCaCertificatesUnionFromJSON(jsonString: string): SafeParseResult<ServerCaCertificatesUnion, SDKValidationError>;
+/** @internal */
+export declare const UsernameSecretRef3$inboundSchema: z.ZodType<UsernameSecretRef3, unknown>;
+/** @internal */
+export type UsernameSecretRef3$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const UsernameSecretRef3$outboundSchema: z.ZodType<UsernameSecretRef3$Outbound, UsernameSecretRef3>;
+export declare function usernameSecretRef3ToJSON(usernameSecretRef3: UsernameSecretRef3): string;
+export declare function usernameSecretRef3FromJSON(jsonString: string): SafeParseResult<UsernameSecretRef3, SDKValidationError>;
+/** @internal */
+export declare const ExternalBindingUsername3$inboundSchema: z.ZodType<ExternalBindingUsername3, unknown>;
+/** @internal */
+export type ExternalBindingUsername3$Outbound = {
+    secretRef: UsernameSecretRef3$Outbound;
+};
+/** @internal */
+export declare const ExternalBindingUsername3$outboundSchema: z.ZodType<ExternalBindingUsername3$Outbound, ExternalBindingUsername3>;
+export declare function externalBindingUsername3ToJSON(externalBindingUsername3: ExternalBindingUsername3): string;
+export declare function externalBindingUsername3FromJSON(jsonString: string): SafeParseResult<ExternalBindingUsername3, SDKValidationError>;
+/** @internal */
+export declare const TypePostgres3$inboundSchema: z.ZodEnum<typeof TypePostgres3>;
+/** @internal */
+export declare const TypePostgres3$outboundSchema: z.ZodEnum<typeof TypePostgres3>;
+/** @internal */
+export declare const ExternalBindingCloudSQL$inboundSchema: z.ZodType<ExternalBindingCloudSQL, unknown>;
+/** @internal */
+export type ExternalBindingCloudSQL$Outbound = {
+    database: any | null;
+    host: any | null;
+    passwordSecretName: any | null;
+    port: Port3$Outbound | number | any | string | null;
+    serverCaCertificates: ServerCaCertificates$Outbound | Array<string> | any | string | null;
+    username: any | null;
+    service: "cloud-sql";
+    type: string;
+};
+/** @internal */
+export declare const ExternalBindingCloudSQL$outboundSchema: z.ZodType<ExternalBindingCloudSQL$Outbound, ExternalBindingCloudSQL>;
+export declare function externalBindingCloudSQLToJSON(externalBindingCloudSQL: ExternalBindingCloudSQL): string;
+export declare function externalBindingCloudSQLFromJSON(jsonString: string): SafeParseResult<ExternalBindingCloudSQL, SDKValidationError>;
+/** @internal */
+export declare const ClusterEndpointSecretRef2$inboundSchema: z.ZodType<ClusterEndpointSecretRef2, unknown>;
+/** @internal */
+export type ClusterEndpointSecretRef2$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const ClusterEndpointSecretRef2$outboundSchema: z.ZodType<ClusterEndpointSecretRef2$Outbound, ClusterEndpointSecretRef2>;
+export declare function clusterEndpointSecretRef2ToJSON(clusterEndpointSecretRef2: ClusterEndpointSecretRef2): string;
+export declare function clusterEndpointSecretRef2FromJSON(jsonString: string): SafeParseResult<ClusterEndpointSecretRef2, SDKValidationError>;
+/** @internal */
+export declare const ClusterEndpoint2$inboundSchema: z.ZodType<ClusterEndpoint2, unknown>;
+/** @internal */
+export type ClusterEndpoint2$Outbound = {
+    secretRef: ClusterEndpointSecretRef2$Outbound;
+};
+/** @internal */
+export declare const ClusterEndpoint2$outboundSchema: z.ZodType<ClusterEndpoint2$Outbound, ClusterEndpoint2>;
+export declare function clusterEndpoint2ToJSON(clusterEndpoint2: ClusterEndpoint2): string;
+export declare function clusterEndpoint2FromJSON(jsonString: string): SafeParseResult<ClusterEndpoint2, SDKValidationError>;
+/** @internal */
+export declare const DatabaseSecretRef3$inboundSchema: z.ZodType<DatabaseSecretRef3, unknown>;
+/** @internal */
+export type DatabaseSecretRef3$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const DatabaseSecretRef3$outboundSchema: z.ZodType<DatabaseSecretRef3$Outbound, DatabaseSecretRef3>;
+export declare function databaseSecretRef3ToJSON(databaseSecretRef3: DatabaseSecretRef3): string;
+export declare function databaseSecretRef3FromJSON(jsonString: string): SafeParseResult<DatabaseSecretRef3, SDKValidationError>;
+/** @internal */
+export declare const Database3$inboundSchema: z.ZodType<Database3, unknown>;
+/** @internal */
+export type Database3$Outbound = {
+    secretRef: DatabaseSecretRef3$Outbound;
+};
+/** @internal */
+export declare const Database3$outboundSchema: z.ZodType<Database3$Outbound, Database3>;
+export declare function database3ToJSON(database3: Database3): string;
+export declare function database3FromJSON(jsonString: string): SafeParseResult<Database3, SDKValidationError>;
+/** @internal */
+export declare const PasswordSecretArnSecretRef2$inboundSchema: z.ZodType<PasswordSecretArnSecretRef2, unknown>;
+/** @internal */
+export type PasswordSecretArnSecretRef2$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const PasswordSecretArnSecretRef2$outboundSchema: z.ZodType<PasswordSecretArnSecretRef2$Outbound, PasswordSecretArnSecretRef2>;
+export declare function passwordSecretArnSecretRef2ToJSON(passwordSecretArnSecretRef2: PasswordSecretArnSecretRef2): string;
+export declare function passwordSecretArnSecretRef2FromJSON(jsonString: string): SafeParseResult<PasswordSecretArnSecretRef2, SDKValidationError>;
+/** @internal */
+export declare const PasswordSecretArn2$inboundSchema: z.ZodType<PasswordSecretArn2, unknown>;
+/** @internal */
+export type PasswordSecretArn2$Outbound = {
+    secretRef: PasswordSecretArnSecretRef2$Outbound;
+};
+/** @internal */
+export declare const PasswordSecretArn2$outboundSchema: z.ZodType<PasswordSecretArn2$Outbound, PasswordSecretArn2>;
+export declare function passwordSecretArn2ToJSON(passwordSecretArn2: PasswordSecretArn2): string;
+export declare function passwordSecretArn2FromJSON(jsonString: string): SafeParseResult<PasswordSecretArn2, SDKValidationError>;
+/** @internal */
+export declare const PortSecretRef2$inboundSchema: z.ZodType<PortSecretRef2, unknown>;
+/** @internal */
+export type PortSecretRef2$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const PortSecretRef2$outboundSchema: z.ZodType<PortSecretRef2$Outbound, PortSecretRef2>;
+export declare function portSecretRef2ToJSON(portSecretRef2: PortSecretRef2): string;
+export declare function portSecretRef2FromJSON(jsonString: string): SafeParseResult<PortSecretRef2, SDKValidationError>;
+/** @internal */
+export declare const Port2$inboundSchema: z.ZodType<Port2, unknown>;
+/** @internal */
+export type Port2$Outbound = {
+    secretRef: PortSecretRef2$Outbound;
+};
+/** @internal */
+export declare const Port2$outboundSchema: z.ZodType<Port2$Outbound, Port2>;
+export declare function port2ToJSON(port2: Port2): string;
+export declare function port2FromJSON(jsonString: string): SafeParseResult<Port2, SDKValidationError>;
+/** @internal */
+export declare const PortUnion2$inboundSchema: z.ZodType<PortUnion2, unknown>;
+/** @internal */
+export type PortUnion2$Outbound = Port2$Outbound | number | any | string;
+/** @internal */
+export declare const PortUnion2$outboundSchema: z.ZodType<PortUnion2$Outbound, PortUnion2>;
+export declare function portUnion2ToJSON(portUnion2: PortUnion2): string;
+export declare function portUnion2FromJSON(jsonString: string): SafeParseResult<PortUnion2, SDKValidationError>;
+/** @internal */
+export declare const UsernameSecretRef2$inboundSchema: z.ZodType<UsernameSecretRef2, unknown>;
+/** @internal */
+export type UsernameSecretRef2$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const UsernameSecretRef2$outboundSchema: z.ZodType<UsernameSecretRef2$Outbound, UsernameSecretRef2>;
+export declare function usernameSecretRef2ToJSON(usernameSecretRef2: UsernameSecretRef2): string;
+export declare function usernameSecretRef2FromJSON(jsonString: string): SafeParseResult<UsernameSecretRef2, SDKValidationError>;
+/** @internal */
+export declare const ExternalBindingUsername2$inboundSchema: z.ZodType<ExternalBindingUsername2, unknown>;
+/** @internal */
+export type ExternalBindingUsername2$Outbound = {
+    secretRef: UsernameSecretRef2$Outbound;
+};
+/** @internal */
+export declare const ExternalBindingUsername2$outboundSchema: z.ZodType<ExternalBindingUsername2$Outbound, ExternalBindingUsername2>;
+export declare function externalBindingUsername2ToJSON(externalBindingUsername2: ExternalBindingUsername2): string;
+export declare function externalBindingUsername2FromJSON(jsonString: string): SafeParseResult<ExternalBindingUsername2, SDKValidationError>;
+/** @internal */
+export declare const TypePostgres2$inboundSchema: z.ZodEnum<typeof TypePostgres2>;
+/** @internal */
+export declare const TypePostgres2$outboundSchema: z.ZodEnum<typeof TypePostgres2>;
+/** @internal */
+export declare const ExternalBindingAuroraManaged$inboundSchema: z.ZodType<ExternalBindingAuroraManaged, unknown>;
+/** @internal */
+export type ExternalBindingAuroraManaged$Outbound = {
+    clusterEndpoint: any | null;
+    database: any | null;
+    passwordSecretArn: any | null;
+    port: Port2$Outbound | number | any | string | null;
+    username: any | null;
+    service: "aurora-managed";
+    type: string;
+};
+/** @internal */
+export declare const ExternalBindingAuroraManaged$outboundSchema: z.ZodType<ExternalBindingAuroraManaged$Outbound, ExternalBindingAuroraManaged>;
+export declare function externalBindingAuroraManagedToJSON(externalBindingAuroraManaged: ExternalBindingAuroraManaged): string;
+export declare function externalBindingAuroraManagedFromJSON(jsonString: string): SafeParseResult<ExternalBindingAuroraManaged, SDKValidationError>;
+/** @internal */
+export declare const ClusterEndpointSecretRef1$inboundSchema: z.ZodType<ClusterEndpointSecretRef1, unknown>;
+/** @internal */
+export type ClusterEndpointSecretRef1$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const ClusterEndpointSecretRef1$outboundSchema: z.ZodType<ClusterEndpointSecretRef1$Outbound, ClusterEndpointSecretRef1>;
+export declare function clusterEndpointSecretRef1ToJSON(clusterEndpointSecretRef1: ClusterEndpointSecretRef1): string;
+export declare function clusterEndpointSecretRef1FromJSON(jsonString: string): SafeParseResult<ClusterEndpointSecretRef1, SDKValidationError>;
+/** @internal */
+export declare const ClusterEndpoint1$inboundSchema: z.ZodType<ClusterEndpoint1, unknown>;
+/** @internal */
+export type ClusterEndpoint1$Outbound = {
+    secretRef: ClusterEndpointSecretRef1$Outbound;
+};
+/** @internal */
+export declare const ClusterEndpoint1$outboundSchema: z.ZodType<ClusterEndpoint1$Outbound, ClusterEndpoint1>;
+export declare function clusterEndpoint1ToJSON(clusterEndpoint1: ClusterEndpoint1): string;
+export declare function clusterEndpoint1FromJSON(jsonString: string): SafeParseResult<ClusterEndpoint1, SDKValidationError>;
+/** @internal */
+export declare const DatabaseSecretRef2$inboundSchema: z.ZodType<DatabaseSecretRef2, unknown>;
+/** @internal */
+export type DatabaseSecretRef2$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const DatabaseSecretRef2$outboundSchema: z.ZodType<DatabaseSecretRef2$Outbound, DatabaseSecretRef2>;
+export declare function databaseSecretRef2ToJSON(databaseSecretRef2: DatabaseSecretRef2): string;
+export declare function databaseSecretRef2FromJSON(jsonString: string): SafeParseResult<DatabaseSecretRef2, SDKValidationError>;
+/** @internal */
+export declare const Database2$inboundSchema: z.ZodType<Database2, unknown>;
+/** @internal */
+export type Database2$Outbound = {
+    secretRef: DatabaseSecretRef2$Outbound;
+};
+/** @internal */
+export declare const Database2$outboundSchema: z.ZodType<Database2$Outbound, Database2>;
+export declare function database2ToJSON(database2: Database2): string;
+export declare function database2FromJSON(jsonString: string): SafeParseResult<Database2, SDKValidationError>;
+/** @internal */
+export declare const PasswordSecretArnSecretRef1$inboundSchema: z.ZodType<PasswordSecretArnSecretRef1, unknown>;
+/** @internal */
+export type PasswordSecretArnSecretRef1$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const PasswordSecretArnSecretRef1$outboundSchema: z.ZodType<PasswordSecretArnSecretRef1$Outbound, PasswordSecretArnSecretRef1>;
+export declare function passwordSecretArnSecretRef1ToJSON(passwordSecretArnSecretRef1: PasswordSecretArnSecretRef1): string;
+export declare function passwordSecretArnSecretRef1FromJSON(jsonString: string): SafeParseResult<PasswordSecretArnSecretRef1, SDKValidationError>;
+/** @internal */
+export declare const PasswordSecretArn1$inboundSchema: z.ZodType<PasswordSecretArn1, unknown>;
+/** @internal */
+export type PasswordSecretArn1$Outbound = {
+    secretRef: PasswordSecretArnSecretRef1$Outbound;
+};
+/** @internal */
+export declare const PasswordSecretArn1$outboundSchema: z.ZodType<PasswordSecretArn1$Outbound, PasswordSecretArn1>;
+export declare function passwordSecretArn1ToJSON(passwordSecretArn1: PasswordSecretArn1): string;
+export declare function passwordSecretArn1FromJSON(jsonString: string): SafeParseResult<PasswordSecretArn1, SDKValidationError>;
+/** @internal */
+export declare const PortSecretRef1$inboundSchema: z.ZodType<PortSecretRef1, unknown>;
+/** @internal */
+export type PortSecretRef1$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const PortSecretRef1$outboundSchema: z.ZodType<PortSecretRef1$Outbound, PortSecretRef1>;
+export declare function portSecretRef1ToJSON(portSecretRef1: PortSecretRef1): string;
+export declare function portSecretRef1FromJSON(jsonString: string): SafeParseResult<PortSecretRef1, SDKValidationError>;
+/** @internal */
+export declare const Port1$inboundSchema: z.ZodType<Port1, unknown>;
+/** @internal */
+export type Port1$Outbound = {
+    secretRef: PortSecretRef1$Outbound;
+};
+/** @internal */
+export declare const Port1$outboundSchema: z.ZodType<Port1$Outbound, Port1>;
+export declare function port1ToJSON(port1: Port1): string;
+export declare function port1FromJSON(jsonString: string): SafeParseResult<Port1, SDKValidationError>;
+/** @internal */
+export declare const PortUnion1$inboundSchema: z.ZodType<PortUnion1, unknown>;
+/** @internal */
+export type PortUnion1$Outbound = Port1$Outbound | number | any | string;
+/** @internal */
+export declare const PortUnion1$outboundSchema: z.ZodType<PortUnion1$Outbound, PortUnion1>;
+export declare function portUnion1ToJSON(portUnion1: PortUnion1): string;
+export declare function portUnion1FromJSON(jsonString: string): SafeParseResult<PortUnion1, SDKValidationError>;
+/** @internal */
+export declare const UsernameSecretRef1$inboundSchema: z.ZodType<UsernameSecretRef1, unknown>;
+/** @internal */
+export type UsernameSecretRef1$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const UsernameSecretRef1$outboundSchema: z.ZodType<UsernameSecretRef1$Outbound, UsernameSecretRef1>;
+export declare function usernameSecretRef1ToJSON(usernameSecretRef1: UsernameSecretRef1): string;
+export declare function usernameSecretRef1FromJSON(jsonString: string): SafeParseResult<UsernameSecretRef1, SDKValidationError>;
+/** @internal */
+export declare const ExternalBindingUsername1$inboundSchema: z.ZodType<ExternalBindingUsername1, unknown>;
+/** @internal */
+export type ExternalBindingUsername1$Outbound = {
+    secretRef: UsernameSecretRef1$Outbound;
+};
+/** @internal */
+export declare const ExternalBindingUsername1$outboundSchema: z.ZodType<ExternalBindingUsername1$Outbound, ExternalBindingUsername1>;
+export declare function externalBindingUsername1ToJSON(externalBindingUsername1: ExternalBindingUsername1): string;
+export declare function externalBindingUsername1FromJSON(jsonString: string): SafeParseResult<ExternalBindingUsername1, SDKValidationError>;
+/** @internal */
+export declare const TypePostgres1$inboundSchema: z.ZodEnum<typeof TypePostgres1>;
+/** @internal */
+export declare const TypePostgres1$outboundSchema: z.ZodEnum<typeof TypePostgres1>;
+/** @internal */
+export declare const ExternalBindingAurora$inboundSchema: z.ZodType<ExternalBindingAurora, unknown>;
+/** @internal */
+export type ExternalBindingAurora$Outbound = {
+    clusterEndpoint: any | null;
+    database: any | null;
+    passwordSecretArn: any | null;
+    port: Port1$Outbound | number | any | string | null;
+    username: any | null;
+    service: "aurora";
+    type: string;
+};
+/** @internal */
+export declare const ExternalBindingAurora$outboundSchema: z.ZodType<ExternalBindingAurora$Outbound, ExternalBindingAurora>;
+export declare function externalBindingAuroraToJSON(externalBindingAurora: ExternalBindingAurora): string;
+export declare function externalBindingAuroraFromJSON(jsonString: string): SafeParseResult<ExternalBindingAurora, SDKValidationError>;
+/** @internal */
+export declare const ExternalBindingUnion6$inboundSchema: z.ZodType<ExternalBindingUnion6, unknown>;
+/** @internal */
+export type ExternalBindingUnion6$Outbound = ExternalBindingAurora$Outbound | ExternalBindingAuroraManaged$Outbound | ExternalBindingCloudSQL$Outbound | ExternalBindingFlexibleServer$Outbound | ExternalBindingExternal$Outbound | ExternalBindingLocalPostgres$Outbound;
+/** @internal */
+export declare const ExternalBindingUnion6$outboundSchema: z.ZodType<ExternalBindingUnion6$Outbound, ExternalBindingUnion6>;
+export declare function externalBindingUnion6ToJSON(externalBindingUnion6: ExternalBindingUnion6): string;
+export declare function externalBindingUnion6FromJSON(jsonString: string): SafeParseResult<ExternalBindingUnion6, SDKValidationError>;
+/** @internal */
+export declare const DefaultDomainSecretRef$inboundSchema: z.ZodType<DefaultDomainSecretRef, unknown>;
+/** @internal */
+export type DefaultDomainSecretRef$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const DefaultDomainSecretRef$outboundSchema: z.ZodType<DefaultDomainSecretRef$Outbound, DefaultDomainSecretRef>;
+export declare function defaultDomainSecretRefToJSON(defaultDomainSecretRef: DefaultDomainSecretRef): string;
+export declare function defaultDomainSecretRefFromJSON(jsonString: string): SafeParseResult<DefaultDomainSecretRef, SDKValidationError>;
+/** @internal */
+export declare const DefaultDomain$inboundSchema: z.ZodType<DefaultDomain, unknown>;
+/** @internal */
+export type DefaultDomain$Outbound = {
+    secretRef: DefaultDomainSecretRef$Outbound;
+};
+/** @internal */
+export declare const DefaultDomain$outboundSchema: z.ZodType<DefaultDomain$Outbound, DefaultDomain>;
+export declare function defaultDomainToJSON(defaultDomain: DefaultDomain): string;
+export declare function defaultDomainFromJSON(jsonString: string): SafeParseResult<DefaultDomain, SDKValidationError>;
+/** @internal */
+export declare const EnvironmentNameSecretRef$inboundSchema: z.ZodType<EnvironmentNameSecretRef, unknown>;
+/** @internal */
+export type EnvironmentNameSecretRef$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const EnvironmentNameSecretRef$outboundSchema: z.ZodType<EnvironmentNameSecretRef$Outbound, EnvironmentNameSecretRef>;
+export declare function environmentNameSecretRefToJSON(environmentNameSecretRef: EnvironmentNameSecretRef): string;
+export declare function environmentNameSecretRefFromJSON(jsonString: string): SafeParseResult<EnvironmentNameSecretRef, SDKValidationError>;
+/** @internal */
+export declare const EnvironmentName$inboundSchema: z.ZodType<EnvironmentName, unknown>;
+/** @internal */
+export type EnvironmentName$Outbound = {
+    secretRef: EnvironmentNameSecretRef$Outbound;
+};
+/** @internal */
+export declare const EnvironmentName$outboundSchema: z.ZodType<EnvironmentName$Outbound, EnvironmentName>;
+export declare function environmentNameToJSON(environmentName: EnvironmentName): string;
+export declare function environmentNameFromJSON(jsonString: string): SafeParseResult<EnvironmentName, SDKValidationError>;
+/** @internal */
+export declare const ResourceGroupNameSecretRef3$inboundSchema: z.ZodType<ResourceGroupNameSecretRef3, unknown>;
+/** @internal */
+export type ResourceGroupNameSecretRef3$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const ResourceGroupNameSecretRef3$outboundSchema: z.ZodType<ResourceGroupNameSecretRef3$Outbound, ResourceGroupNameSecretRef3>;
+export declare function resourceGroupNameSecretRef3ToJSON(resourceGroupNameSecretRef3: ResourceGroupNameSecretRef3): string;
+export declare function resourceGroupNameSecretRef3FromJSON(jsonString: string): SafeParseResult<ResourceGroupNameSecretRef3, SDKValidationError>;
+/** @internal */
+export declare const ResourceGroupName3$inboundSchema: z.ZodType<ResourceGroupName3, unknown>;
+/** @internal */
+export type ResourceGroupName3$Outbound = {
+    secretRef: ResourceGroupNameSecretRef3$Outbound;
+};
+/** @internal */
+export declare const ResourceGroupName3$outboundSchema: z.ZodType<ResourceGroupName3$Outbound, ResourceGroupName3>;
+export declare function resourceGroupName3ToJSON(resourceGroupName3: ResourceGroupName3): string;
+export declare function resourceGroupName3FromJSON(jsonString: string): SafeParseResult<ResourceGroupName3, SDKValidationError>;
+/** @internal */
+export declare const ResourceIdSecretRef$inboundSchema: z.ZodType<ResourceIdSecretRef, unknown>;
+/** @internal */
+export type ResourceIdSecretRef$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const ResourceIdSecretRef$outboundSchema: z.ZodType<ResourceIdSecretRef$Outbound, ResourceIdSecretRef>;
+export declare function resourceIdSecretRefToJSON(resourceIdSecretRef: ResourceIdSecretRef): string;
+export declare function resourceIdSecretRefFromJSON(jsonString: string): SafeParseResult<ResourceIdSecretRef, SDKValidationError>;
+/** @internal */
+export declare const ResourceId$inboundSchema: z.ZodType<ResourceId, unknown>;
+/** @internal */
+export type ResourceId$Outbound = {
+    secretRef: ResourceIdSecretRef$Outbound;
+};
+/** @internal */
+export declare const ResourceId$outboundSchema: z.ZodType<ResourceId$Outbound, ResourceId>;
+export declare function resourceIdToJSON(resourceId: ResourceId): string;
+export declare function resourceIdFromJSON(jsonString: string): SafeParseResult<ResourceId, SDKValidationError>;
+/** @internal */
+export declare const StaticIpSecretRef$inboundSchema: z.ZodType<StaticIpSecretRef, unknown>;
+/** @internal */
+export type StaticIpSecretRef$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const StaticIpSecretRef$outboundSchema: z.ZodType<StaticIpSecretRef$Outbound, StaticIpSecretRef>;
+export declare function staticIpSecretRefToJSON(staticIpSecretRef: StaticIpSecretRef): string;
+export declare function staticIpSecretRefFromJSON(jsonString: string): SafeParseResult<StaticIpSecretRef, SDKValidationError>;
+/** @internal */
+export declare const StaticIp$inboundSchema: z.ZodType<StaticIp, unknown>;
+/** @internal */
+export type StaticIp$Outbound = {
+    secretRef: StaticIpSecretRef$Outbound;
+};
+/** @internal */
+export declare const StaticIp$outboundSchema: z.ZodType<StaticIp$Outbound, StaticIp>;
+export declare function staticIpToJSON(staticIp: StaticIp): string;
+export declare function staticIpFromJSON(jsonString: string): SafeParseResult<StaticIp, SDKValidationError>;
+/** @internal */
+export declare const TypeContainerAppsEnvironment$inboundSchema: z.ZodEnum<typeof TypeContainerAppsEnvironment>;
+/** @internal */
+export declare const TypeContainerAppsEnvironment$outboundSchema: z.ZodEnum<typeof TypeContainerAppsEnvironment>;
+/** @internal */
+export declare const ExternalBindingContainerAppsEnvironment$inboundSchema: z.ZodType<ExternalBindingContainerAppsEnvironment, unknown>;
+/** @internal */
+export type ExternalBindingContainerAppsEnvironment$Outbound = {
+    defaultDomain: any | null;
+    environmentName: any | null;
+    resourceGroupName: any | null;
+    resourceId: any | null;
+    staticIp?: any | null | undefined;
+    type: string;
+};
+/** @internal */
+export declare const ExternalBindingContainerAppsEnvironment$outboundSchema: z.ZodType<ExternalBindingContainerAppsEnvironment$Outbound, ExternalBindingContainerAppsEnvironment>;
+export declare function externalBindingContainerAppsEnvironmentToJSON(externalBindingContainerAppsEnvironment: ExternalBindingContainerAppsEnvironment): string;
+export declare function externalBindingContainerAppsEnvironmentFromJSON(jsonString: string): SafeParseResult<ExternalBindingContainerAppsEnvironment, SDKValidationError>;
+/** @internal */
+export declare const DataDirSecretRef3$inboundSchema: z.ZodType<DataDirSecretRef3, unknown>;
+/** @internal */
+export type DataDirSecretRef3$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const DataDirSecretRef3$outboundSchema: z.ZodType<DataDirSecretRef3$Outbound, DataDirSecretRef3>;
+export declare function dataDirSecretRef3ToJSON(dataDirSecretRef3: DataDirSecretRef3): string;
+export declare function dataDirSecretRef3FromJSON(jsonString: string): SafeParseResult<DataDirSecretRef3, SDKValidationError>;
+/** @internal */
+export declare const DataDir3$inboundSchema: z.ZodType<DataDir3, unknown>;
+/** @internal */
+export type DataDir3$Outbound = {
+    secretRef: DataDirSecretRef3$Outbound;
+};
+/** @internal */
+export declare const DataDir3$outboundSchema: z.ZodType<DataDir3$Outbound, DataDir3>;
+export declare function dataDir3ToJSON(dataDir3: DataDir3): string;
+export declare function dataDir3FromJSON(jsonString: string): SafeParseResult<DataDir3, SDKValidationError>;
+/** @internal */
+export declare const TypeVault5$inboundSchema: z.ZodEnum<typeof TypeVault5>;
+/** @internal */
+export declare const TypeVault5$outboundSchema: z.ZodEnum<typeof TypeVault5>;
+/** @internal */
+export declare const ExternalBindingLocalVault$inboundSchema: z.ZodType<ExternalBindingLocalVault, unknown>;
+/** @internal */
+export type ExternalBindingLocalVault$Outbound = {
+    dataDir: any | null;
+    vaultName: string;
+    service: "local-vault";
+    type: string;
+};
+/** @internal */
+export declare const ExternalBindingLocalVault$outboundSchema: z.ZodType<ExternalBindingLocalVault$Outbound, ExternalBindingLocalVault>;
+export declare function externalBindingLocalVaultToJSON(externalBindingLocalVault: ExternalBindingLocalVault): string;
+export declare function externalBindingLocalVaultFromJSON(jsonString: string): SafeParseResult<ExternalBindingLocalVault, SDKValidationError>;
+/** @internal */
+export declare const NamespaceSecretRef2$inboundSchema: z.ZodType<NamespaceSecretRef2, unknown>;
+/** @internal */
+export type NamespaceSecretRef2$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const NamespaceSecretRef2$outboundSchema: z.ZodType<NamespaceSecretRef2$Outbound, NamespaceSecretRef2>;
+export declare function namespaceSecretRef2ToJSON(namespaceSecretRef2: NamespaceSecretRef2): string;
+export declare function namespaceSecretRef2FromJSON(jsonString: string): SafeParseResult<NamespaceSecretRef2, SDKValidationError>;
+/** @internal */
+export declare const Namespace2$inboundSchema: z.ZodType<Namespace2, unknown>;
+/** @internal */
+export type Namespace2$Outbound = {
+    secretRef: NamespaceSecretRef2$Outbound;
+};
+/** @internal */
+export declare const Namespace2$outboundSchema: z.ZodType<Namespace2$Outbound, Namespace2>;
+export declare function namespace2ToJSON(namespace2: Namespace2): string;
+export declare function namespace2FromJSON(jsonString: string): SafeParseResult<Namespace2, SDKValidationError>;
+/** @internal */
+export declare const VaultPrefixSecretRef3$inboundSchema: z.ZodType<VaultPrefixSecretRef3, unknown>;
+/** @internal */
+export type VaultPrefixSecretRef3$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const VaultPrefixSecretRef3$outboundSchema: z.ZodType<VaultPrefixSecretRef3$Outbound, VaultPrefixSecretRef3>;
+export declare function vaultPrefixSecretRef3ToJSON(vaultPrefixSecretRef3: VaultPrefixSecretRef3): string;
+export declare function vaultPrefixSecretRef3FromJSON(jsonString: string): SafeParseResult<VaultPrefixSecretRef3, SDKValidationError>;
+/** @internal */
+export declare const VaultPrefix3$inboundSchema: z.ZodType<VaultPrefix3, unknown>;
+/** @internal */
+export type VaultPrefix3$Outbound = {
+    secretRef: VaultPrefixSecretRef3$Outbound;
+};
+/** @internal */
+export declare const VaultPrefix3$outboundSchema: z.ZodType<VaultPrefix3$Outbound, VaultPrefix3>;
+export declare function vaultPrefix3ToJSON(vaultPrefix3: VaultPrefix3): string;
+export declare function vaultPrefix3FromJSON(jsonString: string): SafeParseResult<VaultPrefix3, SDKValidationError>;
+/** @internal */
+export declare const TypeVault4$inboundSchema: z.ZodEnum<typeof TypeVault4>;
+/** @internal */
+export declare const TypeVault4$outboundSchema: z.ZodEnum<typeof TypeVault4>;
+/** @internal */
+export declare const ExternalBindingKubernetesSecret$inboundSchema: z.ZodType<ExternalBindingKubernetesSecret, unknown>;
+/** @internal */
+export type ExternalBindingKubernetesSecret$Outbound = {
+    namespace: any | null;
+    vaultPrefix: any | null;
+    service: "kubernetes-secret";
+    type: string;
+};
+/** @internal */
+export declare const ExternalBindingKubernetesSecret$outboundSchema: z.ZodType<ExternalBindingKubernetesSecret$Outbound, ExternalBindingKubernetesSecret>;
+export declare function externalBindingKubernetesSecretToJSON(externalBindingKubernetesSecret: ExternalBindingKubernetesSecret): string;
+export declare function externalBindingKubernetesSecretFromJSON(jsonString: string): SafeParseResult<ExternalBindingKubernetesSecret, SDKValidationError>;
+/** @internal */
+export declare const VaultNameSecretRef$inboundSchema: z.ZodType<VaultNameSecretRef, unknown>;
+/** @internal */
+export type VaultNameSecretRef$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const VaultNameSecretRef$outboundSchema: z.ZodType<VaultNameSecretRef$Outbound, VaultNameSecretRef>;
+export declare function vaultNameSecretRefToJSON(vaultNameSecretRef: VaultNameSecretRef): string;
+export declare function vaultNameSecretRefFromJSON(jsonString: string): SafeParseResult<VaultNameSecretRef, SDKValidationError>;
+/** @internal */
+export declare const VaultName$inboundSchema: z.ZodType<VaultName, unknown>;
+/** @internal */
+export type VaultName$Outbound = {
+    secretRef: VaultNameSecretRef$Outbound;
+};
+/** @internal */
+export declare const VaultName$outboundSchema: z.ZodType<VaultName$Outbound, VaultName>;
+export declare function vaultNameToJSON(vaultName: VaultName): string;
+export declare function vaultNameFromJSON(jsonString: string): SafeParseResult<VaultName, SDKValidationError>;
+/** @internal */
+export declare const TypeVault3$inboundSchema: z.ZodEnum<typeof TypeVault3>;
+/** @internal */
+export declare const TypeVault3$outboundSchema: z.ZodEnum<typeof TypeVault3>;
+/** @internal */
+export declare const ExternalBindingKeyVault$inboundSchema: z.ZodType<ExternalBindingKeyVault, unknown>;
+/** @internal */
+export type ExternalBindingKeyVault$Outbound = {
+    vaultName: any | null;
+    service: "key-vault";
+    type: string;
+};
+/** @internal */
+export declare const ExternalBindingKeyVault$outboundSchema: z.ZodType<ExternalBindingKeyVault$Outbound, ExternalBindingKeyVault>;
+export declare function externalBindingKeyVaultToJSON(externalBindingKeyVault: ExternalBindingKeyVault): string;
+export declare function externalBindingKeyVaultFromJSON(jsonString: string): SafeParseResult<ExternalBindingKeyVault, SDKValidationError>;
+/** @internal */
+export declare const VaultPrefixSecretRef2$inboundSchema: z.ZodType<VaultPrefixSecretRef2, unknown>;
+/** @internal */
+export type VaultPrefixSecretRef2$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const VaultPrefixSecretRef2$outboundSchema: z.ZodType<VaultPrefixSecretRef2$Outbound, VaultPrefixSecretRef2>;
+export declare function vaultPrefixSecretRef2ToJSON(vaultPrefixSecretRef2: VaultPrefixSecretRef2): string;
+export declare function vaultPrefixSecretRef2FromJSON(jsonString: string): SafeParseResult<VaultPrefixSecretRef2, SDKValidationError>;
+/** @internal */
+export declare const VaultPrefix2$inboundSchema: z.ZodType<VaultPrefix2, unknown>;
+/** @internal */
+export type VaultPrefix2$Outbound = {
+    secretRef: VaultPrefixSecretRef2$Outbound;
+};
+/** @internal */
+export declare const VaultPrefix2$outboundSchema: z.ZodType<VaultPrefix2$Outbound, VaultPrefix2>;
+export declare function vaultPrefix2ToJSON(vaultPrefix2: VaultPrefix2): string;
+export declare function vaultPrefix2FromJSON(jsonString: string): SafeParseResult<VaultPrefix2, SDKValidationError>;
+/** @internal */
+export declare const TypeVault2$inboundSchema: z.ZodEnum<typeof TypeVault2>;
+/** @internal */
+export declare const TypeVault2$outboundSchema: z.ZodEnum<typeof TypeVault2>;
+/** @internal */
+export declare const ExternalBindingSecretManager$inboundSchema: z.ZodType<ExternalBindingSecretManager, unknown>;
+/** @internal */
+export type ExternalBindingSecretManager$Outbound = {
+    vaultPrefix: any | null;
+    service: "secret-manager";
+    type: string;
+};
+/** @internal */
+export declare const ExternalBindingSecretManager$outboundSchema: z.ZodType<ExternalBindingSecretManager$Outbound, ExternalBindingSecretManager>;
+export declare function externalBindingSecretManagerToJSON(externalBindingSecretManager: ExternalBindingSecretManager): string;
+export declare function externalBindingSecretManagerFromJSON(jsonString: string): SafeParseResult<ExternalBindingSecretManager, SDKValidationError>;
+/** @internal */
+export declare const VaultPrefixSecretRef1$inboundSchema: z.ZodType<VaultPrefixSecretRef1, unknown>;
+/** @internal */
+export type VaultPrefixSecretRef1$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const VaultPrefixSecretRef1$outboundSchema: z.ZodType<VaultPrefixSecretRef1$Outbound, VaultPrefixSecretRef1>;
+export declare function vaultPrefixSecretRef1ToJSON(vaultPrefixSecretRef1: VaultPrefixSecretRef1): string;
+export declare function vaultPrefixSecretRef1FromJSON(jsonString: string): SafeParseResult<VaultPrefixSecretRef1, SDKValidationError>;
+/** @internal */
+export declare const VaultPrefix1$inboundSchema: z.ZodType<VaultPrefix1, unknown>;
+/** @internal */
+export type VaultPrefix1$Outbound = {
+    secretRef: VaultPrefixSecretRef1$Outbound;
+};
+/** @internal */
+export declare const VaultPrefix1$outboundSchema: z.ZodType<VaultPrefix1$Outbound, VaultPrefix1>;
+export declare function vaultPrefix1ToJSON(vaultPrefix1: VaultPrefix1): string;
+export declare function vaultPrefix1FromJSON(jsonString: string): SafeParseResult<VaultPrefix1, SDKValidationError>;
+/** @internal */
+export declare const TypeVault1$inboundSchema: z.ZodEnum<typeof TypeVault1>;
+/** @internal */
+export declare const TypeVault1$outboundSchema: z.ZodEnum<typeof TypeVault1>;
+/** @internal */
+export declare const ExternalBindingParameterStore$inboundSchema: z.ZodType<ExternalBindingParameterStore, unknown>;
+/** @internal */
+export type ExternalBindingParameterStore$Outbound = {
+    vaultPrefix: any | null;
+    service: "parameter-store";
+    type: string;
+};
+/** @internal */
+export declare const ExternalBindingParameterStore$outboundSchema: z.ZodType<ExternalBindingParameterStore$Outbound, ExternalBindingParameterStore>;
+export declare function externalBindingParameterStoreToJSON(externalBindingParameterStore: ExternalBindingParameterStore): string;
+export declare function externalBindingParameterStoreFromJSON(jsonString: string): SafeParseResult<ExternalBindingParameterStore, SDKValidationError>;
+/** @internal */
+export declare const ExternalBindingUnion5$inboundSchema: z.ZodType<ExternalBindingUnion5, unknown>;
+/** @internal */
+export type ExternalBindingUnion5$Outbound = ExternalBindingParameterStore$Outbound | ExternalBindingSecretManager$Outbound | ExternalBindingKeyVault$Outbound | ExternalBindingKubernetesSecret$Outbound | ExternalBindingLocalVault$Outbound;
+/** @internal */
+export declare const ExternalBindingUnion5$outboundSchema: z.ZodType<ExternalBindingUnion5$Outbound, ExternalBindingUnion5>;
+export declare function externalBindingUnion5ToJSON(externalBindingUnion5: ExternalBindingUnion5): string;
+export declare function externalBindingUnion5FromJSON(jsonString: string): SafeParseResult<ExternalBindingUnion5, SDKValidationError>;
+/** @internal */
+export declare const DataDirSecretRef2$inboundSchema: z.ZodType<DataDirSecretRef2, unknown>;
+/** @internal */
+export type DataDirSecretRef2$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const DataDirSecretRef2$outboundSchema: z.ZodType<DataDirSecretRef2$Outbound, DataDirSecretRef2>;
+export declare function dataDirSecretRef2ToJSON(dataDirSecretRef2: DataDirSecretRef2): string;
+export declare function dataDirSecretRef2FromJSON(jsonString: string): SafeParseResult<DataDirSecretRef2, SDKValidationError>;
+/** @internal */
+export declare const DataDir2$inboundSchema: z.ZodType<DataDir2, unknown>;
+/** @internal */
+export type DataDir2$Outbound = {
+    secretRef: DataDirSecretRef2$Outbound;
+};
+/** @internal */
+export declare const DataDir2$outboundSchema: z.ZodType<DataDir2$Outbound, DataDir2>;
+export declare function dataDir2ToJSON(dataDir2: DataDir2): string;
+export declare function dataDir2FromJSON(jsonString: string): SafeParseResult<DataDir2, SDKValidationError>;
+/** @internal */
+export declare const RegistryUrlSecretRef$inboundSchema: z.ZodType<RegistryUrlSecretRef, unknown>;
+/** @internal */
+export type RegistryUrlSecretRef$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const RegistryUrlSecretRef$outboundSchema: z.ZodType<RegistryUrlSecretRef$Outbound, RegistryUrlSecretRef>;
+export declare function registryUrlSecretRefToJSON(registryUrlSecretRef: RegistryUrlSecretRef): string;
+export declare function registryUrlSecretRefFromJSON(jsonString: string): SafeParseResult<RegistryUrlSecretRef, SDKValidationError>;
+/** @internal */
+export declare const RegistryUrl$inboundSchema: z.ZodType<RegistryUrl, unknown>;
+/** @internal */
+export type RegistryUrl$Outbound = {
+    secretRef: RegistryUrlSecretRef$Outbound;
+};
+/** @internal */
+export declare const RegistryUrl$outboundSchema: z.ZodType<RegistryUrl$Outbound, RegistryUrl>;
+export declare function registryUrlToJSON(registryUrl: RegistryUrl): string;
+export declare function registryUrlFromJSON(jsonString: string): SafeParseResult<RegistryUrl, SDKValidationError>;
+/** @internal */
+export declare const TypeArtifactRegistry4$inboundSchema: z.ZodEnum<typeof TypeArtifactRegistry4>;
+/** @internal */
+export declare const TypeArtifactRegistry4$outboundSchema: z.ZodEnum<typeof TypeArtifactRegistry4>;
+/** @internal */
+export declare const ExternalBindingLocal$inboundSchema: z.ZodType<ExternalBindingLocal, unknown>;
+/** @internal */
+export type ExternalBindingLocal$Outbound = {
+    dataDir: any | null;
+    registryUrl: any | null;
+    service: "local";
+    type: string;
+};
+/** @internal */
+export declare const ExternalBindingLocal$outboundSchema: z.ZodType<ExternalBindingLocal$Outbound, ExternalBindingLocal>;
+export declare function externalBindingLocalToJSON(externalBindingLocal: ExternalBindingLocal): string;
+export declare function externalBindingLocalFromJSON(jsonString: string): SafeParseResult<ExternalBindingLocal, SDKValidationError>;
+/** @internal */
+export declare const PullServiceAccountEmailSecretRef$inboundSchema: z.ZodType<PullServiceAccountEmailSecretRef, unknown>;
+/** @internal */
+export type PullServiceAccountEmailSecretRef$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const PullServiceAccountEmailSecretRef$outboundSchema: z.ZodType<PullServiceAccountEmailSecretRef$Outbound, PullServiceAccountEmailSecretRef>;
+export declare function pullServiceAccountEmailSecretRefToJSON(pullServiceAccountEmailSecretRef: PullServiceAccountEmailSecretRef): string;
+export declare function pullServiceAccountEmailSecretRefFromJSON(jsonString: string): SafeParseResult<PullServiceAccountEmailSecretRef, SDKValidationError>;
+/** @internal */
+export declare const PullServiceAccountEmail$inboundSchema: z.ZodType<PullServiceAccountEmail, unknown>;
+/** @internal */
+export type PullServiceAccountEmail$Outbound = {
+    secretRef: PullServiceAccountEmailSecretRef$Outbound;
+};
+/** @internal */
+export declare const PullServiceAccountEmail$outboundSchema: z.ZodType<PullServiceAccountEmail$Outbound, PullServiceAccountEmail>;
+export declare function pullServiceAccountEmailToJSON(pullServiceAccountEmail: PullServiceAccountEmail): string;
+export declare function pullServiceAccountEmailFromJSON(jsonString: string): SafeParseResult<PullServiceAccountEmail, SDKValidationError>;
+/** @internal */
+export declare const PushServiceAccountEmailSecretRef$inboundSchema: z.ZodType<PushServiceAccountEmailSecretRef, unknown>;
+/** @internal */
+export type PushServiceAccountEmailSecretRef$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const PushServiceAccountEmailSecretRef$outboundSchema: z.ZodType<PushServiceAccountEmailSecretRef$Outbound, PushServiceAccountEmailSecretRef>;
+export declare function pushServiceAccountEmailSecretRefToJSON(pushServiceAccountEmailSecretRef: PushServiceAccountEmailSecretRef): string;
+export declare function pushServiceAccountEmailSecretRefFromJSON(jsonString: string): SafeParseResult<PushServiceAccountEmailSecretRef, SDKValidationError>;
+/** @internal */
+export declare const PushServiceAccountEmail$inboundSchema: z.ZodType<PushServiceAccountEmail, unknown>;
+/** @internal */
+export type PushServiceAccountEmail$Outbound = {
+    secretRef: PushServiceAccountEmailSecretRef$Outbound;
+};
+/** @internal */
+export declare const PushServiceAccountEmail$outboundSchema: z.ZodType<PushServiceAccountEmail$Outbound, PushServiceAccountEmail>;
+export declare function pushServiceAccountEmailToJSON(pushServiceAccountEmail: PushServiceAccountEmail): string;
+export declare function pushServiceAccountEmailFromJSON(jsonString: string): SafeParseResult<PushServiceAccountEmail, SDKValidationError>;
+/** @internal */
+export declare const RepositoryNameSecretRef$inboundSchema: z.ZodType<RepositoryNameSecretRef, unknown>;
+/** @internal */
+export type RepositoryNameSecretRef$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const RepositoryNameSecretRef$outboundSchema: z.ZodType<RepositoryNameSecretRef$Outbound, RepositoryNameSecretRef>;
+export declare function repositoryNameSecretRefToJSON(repositoryNameSecretRef: RepositoryNameSecretRef): string;
+export declare function repositoryNameSecretRefFromJSON(jsonString: string): SafeParseResult<RepositoryNameSecretRef, SDKValidationError>;
+/** @internal */
+export declare const RepositoryName$inboundSchema: z.ZodType<RepositoryName, unknown>;
+/** @internal */
+export type RepositoryName$Outbound = {
+    secretRef: RepositoryNameSecretRef$Outbound;
+};
+/** @internal */
+export declare const RepositoryName$outboundSchema: z.ZodType<RepositoryName$Outbound, RepositoryName>;
+export declare function repositoryNameToJSON(repositoryName: RepositoryName): string;
+export declare function repositoryNameFromJSON(jsonString: string): SafeParseResult<RepositoryName, SDKValidationError>;
+/** @internal */
+export declare const TypeArtifactRegistry3$inboundSchema: z.ZodEnum<typeof TypeArtifactRegistry3>;
+/** @internal */
+export declare const TypeArtifactRegistry3$outboundSchema: z.ZodEnum<typeof TypeArtifactRegistry3>;
+/** @internal */
+export declare const ExternalBindingGar$inboundSchema: z.ZodType<ExternalBindingGar, unknown>;
+/** @internal */
+export type ExternalBindingGar$Outbound = {
+    pullServiceAccountEmail?: any | null | undefined;
+    pushServiceAccountEmail?: any | null | undefined;
+    repositoryName: any | null;
+    service: "gar";
+    type: string;
+};
+/** @internal */
+export declare const ExternalBindingGar$outboundSchema: z.ZodType<ExternalBindingGar$Outbound, ExternalBindingGar>;
+export declare function externalBindingGarToJSON(externalBindingGar: ExternalBindingGar): string;
+export declare function externalBindingGarFromJSON(jsonString: string): SafeParseResult<ExternalBindingGar, SDKValidationError>;
+/** @internal */
+export declare const RegistryNameSecretRef$inboundSchema: z.ZodType<RegistryNameSecretRef, unknown>;
+/** @internal */
+export type RegistryNameSecretRef$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const RegistryNameSecretRef$outboundSchema: z.ZodType<RegistryNameSecretRef$Outbound, RegistryNameSecretRef>;
+export declare function registryNameSecretRefToJSON(registryNameSecretRef: RegistryNameSecretRef): string;
+export declare function registryNameSecretRefFromJSON(jsonString: string): SafeParseResult<RegistryNameSecretRef, SDKValidationError>;
+/** @internal */
+export declare const RegistryName$inboundSchema: z.ZodType<RegistryName, unknown>;
+/** @internal */
+export type RegistryName$Outbound = {
+    secretRef: RegistryNameSecretRef$Outbound;
+};
+/** @internal */
+export declare const RegistryName$outboundSchema: z.ZodType<RegistryName$Outbound, RegistryName>;
+export declare function registryNameToJSON(registryName: RegistryName): string;
+export declare function registryNameFromJSON(jsonString: string): SafeParseResult<RegistryName, SDKValidationError>;
+/** @internal */
+export declare const RepositoryPrefixSecretRef2$inboundSchema: z.ZodType<RepositoryPrefixSecretRef2, unknown>;
+/** @internal */
+export type RepositoryPrefixSecretRef2$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const RepositoryPrefixSecretRef2$outboundSchema: z.ZodType<RepositoryPrefixSecretRef2$Outbound, RepositoryPrefixSecretRef2>;
+export declare function repositoryPrefixSecretRef2ToJSON(repositoryPrefixSecretRef2: RepositoryPrefixSecretRef2): string;
+export declare function repositoryPrefixSecretRef2FromJSON(jsonString: string): SafeParseResult<RepositoryPrefixSecretRef2, SDKValidationError>;
+/** @internal */
+export declare const RepositoryPrefix2$inboundSchema: z.ZodType<RepositoryPrefix2, unknown>;
+/** @internal */
+export type RepositoryPrefix2$Outbound = {
+    secretRef: RepositoryPrefixSecretRef2$Outbound;
+};
+/** @internal */
+export declare const RepositoryPrefix2$outboundSchema: z.ZodType<RepositoryPrefix2$Outbound, RepositoryPrefix2>;
+export declare function repositoryPrefix2ToJSON(repositoryPrefix2: RepositoryPrefix2): string;
+export declare function repositoryPrefix2FromJSON(jsonString: string): SafeParseResult<RepositoryPrefix2, SDKValidationError>;
+/** @internal */
+export declare const ResourceGroupNameSecretRef2$inboundSchema: z.ZodType<ResourceGroupNameSecretRef2, unknown>;
+/** @internal */
+export type ResourceGroupNameSecretRef2$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const ResourceGroupNameSecretRef2$outboundSchema: z.ZodType<ResourceGroupNameSecretRef2$Outbound, ResourceGroupNameSecretRef2>;
+export declare function resourceGroupNameSecretRef2ToJSON(resourceGroupNameSecretRef2: ResourceGroupNameSecretRef2): string;
+export declare function resourceGroupNameSecretRef2FromJSON(jsonString: string): SafeParseResult<ResourceGroupNameSecretRef2, SDKValidationError>;
+/** @internal */
+export declare const ResourceGroupName2$inboundSchema: z.ZodType<ResourceGroupName2, unknown>;
+/** @internal */
+export type ResourceGroupName2$Outbound = {
+    secretRef: ResourceGroupNameSecretRef2$Outbound;
+};
+/** @internal */
+export declare const ResourceGroupName2$outboundSchema: z.ZodType<ResourceGroupName2$Outbound, ResourceGroupName2>;
+export declare function resourceGroupName2ToJSON(resourceGroupName2: ResourceGroupName2): string;
+export declare function resourceGroupName2FromJSON(jsonString: string): SafeParseResult<ResourceGroupName2, SDKValidationError>;
+/** @internal */
+export declare const TypeArtifactRegistry2$inboundSchema: z.ZodEnum<typeof TypeArtifactRegistry2>;
+/** @internal */
+export declare const TypeArtifactRegistry2$outboundSchema: z.ZodEnum<typeof TypeArtifactRegistry2>;
+/** @internal */
+export declare const ExternalBindingAcr$inboundSchema: z.ZodType<ExternalBindingAcr, unknown>;
+/** @internal */
+export type ExternalBindingAcr$Outbound = {
+    registryName: any | null;
+    repositoryPrefix?: any | null | undefined;
+    resourceGroupName: any | null;
+    service: "acr";
+    type: string;
+};
+/** @internal */
+export declare const ExternalBindingAcr$outboundSchema: z.ZodType<ExternalBindingAcr$Outbound, ExternalBindingAcr>;
+export declare function externalBindingAcrToJSON(externalBindingAcr: ExternalBindingAcr): string;
+export declare function externalBindingAcrFromJSON(jsonString: string): SafeParseResult<ExternalBindingAcr, SDKValidationError>;
+/** @internal */
+export declare const PullRoleArnSecretRef$inboundSchema: z.ZodType<PullRoleArnSecretRef, unknown>;
+/** @internal */
+export type PullRoleArnSecretRef$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const PullRoleArnSecretRef$outboundSchema: z.ZodType<PullRoleArnSecretRef$Outbound, PullRoleArnSecretRef>;
+export declare function pullRoleArnSecretRefToJSON(pullRoleArnSecretRef: PullRoleArnSecretRef): string;
+export declare function pullRoleArnSecretRefFromJSON(jsonString: string): SafeParseResult<PullRoleArnSecretRef, SDKValidationError>;
+/** @internal */
+export declare const PullRoleArn$inboundSchema: z.ZodType<PullRoleArn, unknown>;
+/** @internal */
+export type PullRoleArn$Outbound = {
+    secretRef: PullRoleArnSecretRef$Outbound;
+};
+/** @internal */
+export declare const PullRoleArn$outboundSchema: z.ZodType<PullRoleArn$Outbound, PullRoleArn>;
+export declare function pullRoleArnToJSON(pullRoleArn: PullRoleArn): string;
+export declare function pullRoleArnFromJSON(jsonString: string): SafeParseResult<PullRoleArn, SDKValidationError>;
+/** @internal */
+export declare const PushRoleArnSecretRef$inboundSchema: z.ZodType<PushRoleArnSecretRef, unknown>;
+/** @internal */
+export type PushRoleArnSecretRef$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const PushRoleArnSecretRef$outboundSchema: z.ZodType<PushRoleArnSecretRef$Outbound, PushRoleArnSecretRef>;
+export declare function pushRoleArnSecretRefToJSON(pushRoleArnSecretRef: PushRoleArnSecretRef): string;
+export declare function pushRoleArnSecretRefFromJSON(jsonString: string): SafeParseResult<PushRoleArnSecretRef, SDKValidationError>;
+/** @internal */
+export declare const PushRoleArn$inboundSchema: z.ZodType<PushRoleArn, unknown>;
+/** @internal */
+export type PushRoleArn$Outbound = {
+    secretRef: PushRoleArnSecretRef$Outbound;
+};
+/** @internal */
+export declare const PushRoleArn$outboundSchema: z.ZodType<PushRoleArn$Outbound, PushRoleArn>;
+export declare function pushRoleArnToJSON(pushRoleArn: PushRoleArn): string;
+export declare function pushRoleArnFromJSON(jsonString: string): SafeParseResult<PushRoleArn, SDKValidationError>;
+/** @internal */
+export declare const RepositoryPrefixSecretRef1$inboundSchema: z.ZodType<RepositoryPrefixSecretRef1, unknown>;
+/** @internal */
+export type RepositoryPrefixSecretRef1$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const RepositoryPrefixSecretRef1$outboundSchema: z.ZodType<RepositoryPrefixSecretRef1$Outbound, RepositoryPrefixSecretRef1>;
+export declare function repositoryPrefixSecretRef1ToJSON(repositoryPrefixSecretRef1: RepositoryPrefixSecretRef1): string;
+export declare function repositoryPrefixSecretRef1FromJSON(jsonString: string): SafeParseResult<RepositoryPrefixSecretRef1, SDKValidationError>;
+/** @internal */
+export declare const RepositoryPrefix1$inboundSchema: z.ZodType<RepositoryPrefix1, unknown>;
+/** @internal */
+export type RepositoryPrefix1$Outbound = {
+    secretRef: RepositoryPrefixSecretRef1$Outbound;
+};
+/** @internal */
+export declare const RepositoryPrefix1$outboundSchema: z.ZodType<RepositoryPrefix1$Outbound, RepositoryPrefix1>;
+export declare function repositoryPrefix1ToJSON(repositoryPrefix1: RepositoryPrefix1): string;
+export declare function repositoryPrefix1FromJSON(jsonString: string): SafeParseResult<RepositoryPrefix1, SDKValidationError>;
+/** @internal */
+export declare const SandboxRepositoryPrefixSecretRef$inboundSchema: z.ZodType<SandboxRepositoryPrefixSecretRef, unknown>;
+/** @internal */
+export type SandboxRepositoryPrefixSecretRef$Outbound = {
+    key: string;
+    name: string;
+};
+/** @internal */
+export declare const SandboxRepositoryPrefixSecretRef$outboundSchema: z.ZodType<SandboxRepositoryPrefixSecretRef$Outbound, SandboxRepositoryPrefixSecretRef>;
+export declare function sandboxRepositoryPrefixSecretRefToJSON(sandboxRepositoryPrefixSecretRef: SandboxRepositoryPrefixSecretRef): string;
+export declare function sandboxRepositoryPrefixSecretRefFromJSON(jsonString: string): SafeParseResult<SandboxRepositoryPrefixSecretRef, SDKValidationError>;
+/** @internal */
+export declare const SandboxRepositoryPrefix$inboundSchema: z.ZodType<SandboxRepositoryPrefix, unknown>;
+/** @internal */
+export type SandboxRepositoryPrefix$Outbound = {
+    secretRef: SandboxRepositoryPrefixSecretRef$Outbound;
+};
+/** @internal */
+export declare const SandboxRepositoryPrefix$outboundSchema: z.ZodType<SandboxRepositoryPrefix$Outbound, SandboxRepositoryPrefix>;
+export declare function sandboxRepositoryPrefixToJSON(sandboxRepositoryPrefix: SandboxRepositoryPrefix): string;
+export declare function sandboxRepositoryPrefixFromJSON(jsonString: string): SafeParseResult<SandboxRepositoryPrefix, SDKValidationError>;
+/** @internal */
+export declare const TypeArtifactRegistry1$inboundSchema: z.ZodEnum<typeof TypeArtifactRegistry1>;
+/** @internal */
+export declare const TypeArtifactRegistry1$outboundSchema: z.ZodEnum<typeof TypeArtifactRegistry1>;
+/** @internal */
+export declare const ExternalBindingEcr$inboundSchema: z.ZodType<ExternalBindingEcr, unknown>;
+/** @internal */
+export type ExternalBindingEcr$Outbound = {
+    legacyRepositoryPrefixes?: Array<string> | undefined;
+    legacySandboxRepositoryPrefixes?: Array<string> | undefined;
+    pullRoleArn?: any | null | undefined;
+    pushRoleArn?: any | null | undefined;
+    repositoryPrefix: any | null;
+    sandboxRepositoryPrefix?: any | null | undefined;
+    service: "ecr";
+    type: string;
+};
+/** @internal */
+export declare const ExternalBindingEcr$outboundSchema: z.ZodType<ExternalBindingEcr$Outbound, ExternalBindingEcr>;
+export declare function externalBindingEcrToJSON(externalBindingEcr: ExternalBindingEcr): string;
+export declare function externalBindingEcrFromJSON(jsonString: string): SafeParseResult<ExternalBindingEcr, SDKValidationError>;
+export type { ClusterEndpointSecretRef1 as ClusterEndpointSecretRef };
+export type { ClusterEndpoint1 as ClusterEndpoint };
+export type { PasswordSecretArnSecretRef1 as PasswordSecretArnSecretRef };
+export type { PasswordSecretArn1 as PasswordSecretArn };
+export { ClusterEndpointSecretRef1$inboundSchema as ClusterEndpointSecretRef$inboundSchema };
+export type { ClusterEndpointSecretRef1$Outbound as ClusterEndpointSecretRef$Outbound };
+export { ClusterEndpointSecretRef1$outboundSchema as ClusterEndpointSecretRef$outboundSchema };
+export { clusterEndpointSecretRef1ToJSON as clusterEndpointSecretRefToJSON };
+export { clusterEndpointSecretRef1FromJSON as clusterEndpointSecretRefFromJSON };
+export { ClusterEndpoint1$inboundSchema as ClusterEndpoint$inboundSchema };
+export type { ClusterEndpoint1$Outbound as ClusterEndpoint$Outbound };
+export { ClusterEndpoint1$outboundSchema as ClusterEndpoint$outboundSchema };
+export { clusterEndpoint1ToJSON as clusterEndpointToJSON };
+export { clusterEndpoint1FromJSON as clusterEndpointFromJSON };
+export { PasswordSecretArnSecretRef1$inboundSchema as PasswordSecretArnSecretRef$inboundSchema };
+export type { PasswordSecretArnSecretRef1$Outbound as PasswordSecretArnSecretRef$Outbound };
+export { PasswordSecretArnSecretRef1$outboundSchema as PasswordSecretArnSecretRef$outboundSchema };
+export { passwordSecretArnSecretRef1ToJSON as passwordSecretArnSecretRefToJSON };
+export { passwordSecretArnSecretRef1FromJSON as passwordSecretArnSecretRefFromJSON };
+export { PasswordSecretArn1$inboundSchema as PasswordSecretArn$inboundSchema };
+export type { PasswordSecretArn1$Outbound as PasswordSecretArn$Outbound };
+export { PasswordSecretArn1$outboundSchema as PasswordSecretArn$outboundSchema };
+export { passwordSecretArn1ToJSON as passwordSecretArnToJSON };
+export { passwordSecretArn1FromJSON as passwordSecretArnFromJSON };
+//# sourceMappingURL=externalbindingecr.d.ts.map