@alienplatform/platform-api 3.3.28 → 3.3.29

package/src/models/externalbindingunion.ts

@@ -0,0 +1,3354 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import {
+  DatabaseUnion,
+  DatabaseUnion$inboundSchema,
+  DatabaseUnion$Outbound,
+  DatabaseUnion$outboundSchema,
+  ExternalBindingAi,
+  ExternalBindingAi$inboundSchema,
+  ExternalBindingAi$Outbound,
+  ExternalBindingAi$outboundSchema,
+  ExternalBindingContainerAppsEnvironment,
+  ExternalBindingContainerAppsEnvironment$inboundSchema,
+  ExternalBindingContainerAppsEnvironment$Outbound,
+  ExternalBindingContainerAppsEnvironment$outboundSchema,
+  ExternalBindingLocalKv,
+  ExternalBindingLocalKv$inboundSchema,
+  ExternalBindingLocalKv$Outbound,
+  ExternalBindingLocalKv$outboundSchema,
+  ExternalBindingUnion4,
+  ExternalBindingUnion4$inboundSchema,
+  ExternalBindingUnion4$Outbound,
+  ExternalBindingUnion4$outboundSchema,
+  ExternalBindingUnion5,
+  ExternalBindingUnion5$inboundSchema,
+  ExternalBindingUnion5$Outbound,
+  ExternalBindingUnion5$outboundSchema,
+  ExternalBindingUnion6,
+  ExternalBindingUnion6$inboundSchema,
+  ExternalBindingUnion6$Outbound,
+  ExternalBindingUnion6$outboundSchema,
+  TypeKv4,
+  TypeKv4$inboundSchema,
+  TypeKv4$outboundSchema,
+} from "./typekv4.js";
+
+/**
+ * Redis KV binding configuration
+ */
+export type ExternalBindingRedis = {
+  /**
+   * Represents a value that can be either a concrete value, a template expression,
+   *
+   * @remarks
+   * or a reference to a Kubernetes Secret
+   */
+  connectionUrl: any | null;
+  database?: DatabaseUnion | null | undefined;
+  keyPrefix?: any | null | undefined;
+  service: "redis";
+  type: TypeKv4;
+};
+
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type AccountNameSecretRef2 = {
+  key: string;
+  name: string;
+};
+
+export type AccountName2 = {
+  /**
+   * Reference to a Kubernetes Secret
+   */
+  secretRef: AccountNameSecretRef2;
+};
+
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type ResourceGroupNameSecretRef1 = {
+  key: string;
+  name: string;
+};
+
+export type ResourceGroupName1 = {
+  /**
+   * Reference to a Kubernetes Secret
+   */
+  secretRef: ResourceGroupNameSecretRef1;
+};
+
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type TableNameSecretRef2 = {
+  key: string;
+  name: string;
+};
+
+export type TableName2 = {
+  /**
+   * Reference to a Kubernetes Secret
+   */
+  secretRef: TableNameSecretRef2;
+};
+
+export const TypeKv3 = {
+  Kv: "kv",
+} as const;
+export type TypeKv3 = ClosedEnum<typeof TypeKv3>;
+
+/**
+ * Azure Table Storage KV binding configuration
+ */
+export type ExternalBindingTablestorage = {
+  /**
+   * Represents a value that can be either a concrete value, a template expression,
+   *
+   * @remarks
+   * or a reference to a Kubernetes Secret
+   */
+  accountName: 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
+   */
+  tableName: any | null;
+  service: "tablestorage";
+  type: TypeKv3;
+};
+
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type CollectionNameSecretRef = {
+  key: string;
+  name: string;
+};
+
+export type CollectionName = {
+  /**
+   * Reference to a Kubernetes Secret
+   */
+  secretRef: CollectionNameSecretRef;
+};
+
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type DatabaseIdSecretRef = {
+  key: string;
+  name: string;
+};
+
+export type DatabaseId = {
+  /**
+   * Reference to a Kubernetes Secret
+   */
+  secretRef: DatabaseIdSecretRef;
+};
+
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type ProjectIdSecretRef = {
+  key: string;
+  name: string;
+};
+
+export type ProjectId = {
+  /**
+   * Reference to a Kubernetes Secret
+   */
+  secretRef: ProjectIdSecretRef;
+};
+
+export const TypeKv2 = {
+  Kv: "kv",
+} as const;
+export type TypeKv2 = ClosedEnum<typeof TypeKv2>;
+
+/**
+ * GCP Firestore KV binding configuration
+ */
+export type ExternalBindingFirestore = {
+  /**
+   * Represents a value that can be either a concrete value, a template expression,
+   *
+   * @remarks
+   * or a reference to a Kubernetes Secret
+   */
+  collectionName: any | null;
+  /**
+   * Represents a value that can be either a concrete value, a template expression,
+   *
+   * @remarks
+   * or a reference to a Kubernetes Secret
+   */
+  databaseId: any | null;
+  /**
+   * Represents a value that can be either a concrete value, a template expression,
+   *
+   * @remarks
+   * or a reference to a Kubernetes Secret
+   */
+  projectId: any | null;
+  service: "firestore";
+  type: TypeKv2;
+};
+
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type EndpointUrlSecretRef = {
+  key: string;
+  name: string;
+};
+
+export type EndpointUrl = {
+  /**
+   * Reference to a Kubernetes Secret
+   */
+  secretRef: EndpointUrlSecretRef;
+};
+
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type RegionSecretRef2 = {
+  key: string;
+  name: string;
+};
+
+export type Region2 = {
+  /**
+   * Reference to a Kubernetes Secret
+   */
+  secretRef: RegionSecretRef2;
+};
+
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type TableNameSecretRef1 = {
+  key: string;
+  name: string;
+};
+
+export type TableName1 = {
+  /**
+   * Reference to a Kubernetes Secret
+   */
+  secretRef: TableNameSecretRef1;
+};
+
+export const TypeKv1 = {
+  Kv: "kv",
+} as const;
+export type TypeKv1 = ClosedEnum<typeof TypeKv1>;
+
+/**
+ * AWS DynamoDB KV binding configuration
+ */
+export type ExternalBindingDynamodb = {
+  endpointUrl?: any | null | undefined;
+  /**
+   * Represents a value that can be either a concrete value, a template expression,
+   *
+   * @remarks
+   * or a reference to a Kubernetes Secret
+   */
+  region: any | null;
+  /**
+   * Represents a value that can be either a concrete value, a template expression,
+   *
+   * @remarks
+   * or a reference to a Kubernetes Secret
+   */
+  tableName: any | null;
+  service: "dynamodb";
+  type: TypeKv1;
+};
+
+/**
+ * Represents a KV binding for key-value storage across platforms
+ */
+export type ExternalBindingUnion3 =
+  | ExternalBindingDynamodb
+  | ExternalBindingFirestore
+  | ExternalBindingTablestorage
+  | ExternalBindingRedis
+  | ExternalBindingLocalKv;
+
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type QueuePathSecretRef = {
+  key: string;
+  name: string;
+};
+
+export type QueuePath = {
+  /**
+   * Reference to a Kubernetes Secret
+   */
+  secretRef: QueuePathSecretRef;
+};
+
+export const TypeQueue4 = {
+  Queue: "queue",
+} as const;
+export type TypeQueue4 = ClosedEnum<typeof TypeQueue4>;
+
+/**
+ * Local queue parameters
+ */
+export type ExternalBindingLocalQueue = {
+  /**
+   * Represents a value that can be either a concrete value, a template expression,
+   *
+   * @remarks
+   * or a reference to a Kubernetes Secret
+   */
+  queuePath: any | null;
+  service: "local-queue";
+  type: TypeQueue4;
+};
+
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type NamespaceSecretRef1 = {
+  key: string;
+  name: string;
+};
+
+export type Namespace1 = {
+  /**
+   * Reference to a Kubernetes Secret
+   */
+  secretRef: NamespaceSecretRef1;
+};
+
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type QueueNameSecretRef = {
+  key: string;
+  name: string;
+};
+
+export type QueueName = {
+  /**
+   * Reference to a Kubernetes Secret
+   */
+  secretRef: QueueNameSecretRef;
+};
+
+export const TypeQueue3 = {
+  Queue: "queue",
+} as const;
+export type TypeQueue3 = ClosedEnum<typeof TypeQueue3>;
+
+/**
+ * Azure Service Bus parameters
+ */
+export type ExternalBindingServicebus = {
+  /**
+   * 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
+   */
+  queueName: any | null;
+  service: "servicebus";
+  type: TypeQueue3;
+};
+
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type SubscriptionSecretRef = {
+  key: string;
+  name: string;
+};
+
+export type Subscription = {
+  /**
+   * Reference to a Kubernetes Secret
+   */
+  secretRef: SubscriptionSecretRef;
+};
+
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type TopicSecretRef = {
+  key: string;
+  name: string;
+};
+
+export type Topic = {
+  /**
+   * Reference to a Kubernetes Secret
+   */
+  secretRef: TopicSecretRef;
+};
+
+export const TypeQueue2 = {
+  Queue: "queue",
+} as const;
+export type TypeQueue2 = ClosedEnum<typeof TypeQueue2>;
+
+/**
+ * GCP Pub/Sub parameters
+ */
+export type ExternalBindingPubsub = {
+  /**
+   * Represents a value that can be either a concrete value, a template expression,
+   *
+   * @remarks
+   * or a reference to a Kubernetes Secret
+   */
+  subscription: any | null;
+  /**
+   * Represents a value that can be either a concrete value, a template expression,
+   *
+   * @remarks
+   * or a reference to a Kubernetes Secret
+   */
+  topic: any | null;
+  service: "pubsub";
+  type: TypeQueue2;
+};
+
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type QueueUrlSecretRef = {
+  key: string;
+  name: string;
+};
+
+export type QueueUrl = {
+  /**
+   * Reference to a Kubernetes Secret
+   */
+  secretRef: QueueUrlSecretRef;
+};
+
+export const TypeQueue1 = {
+  Queue: "queue",
+} as const;
+export type TypeQueue1 = ClosedEnum<typeof TypeQueue1>;
+
+/**
+ * AWS SQS queue parameters
+ */
+export type ExternalBindingSqs = {
+  /**
+   * Represents a value that can be either a concrete value, a template expression,
+   *
+   * @remarks
+   * or a reference to a Kubernetes Secret
+   */
+  queueUrl: any | null;
+  service: "sqs";
+  type: TypeQueue1;
+};
+
+/**
+ * Binding parameters for Queue at runtime or in templates.
+ */
+export type ExternalBindingUnion2 =
+  | ExternalBindingSqs
+  | ExternalBindingPubsub
+  | ExternalBindingServicebus
+  | ExternalBindingLocalQueue;
+
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type StoragePathSecretRef = {
+  key: string;
+  name: string;
+};
+
+export type StoragePath = {
+  /**
+   * Reference to a Kubernetes Secret
+   */
+  secretRef: StoragePathSecretRef;
+};
+
+export const TypeStorage4 = {
+  Storage: "storage",
+} as const;
+export type TypeStorage4 = ClosedEnum<typeof TypeStorage4>;
+
+/**
+ * Local filesystem storage binding configuration
+ */
+export type ExternalBindingLocalStorage = {
+  /**
+   * Represents a value that can be either a concrete value, a template expression,
+   *
+   * @remarks
+   * or a reference to a Kubernetes Secret
+   */
+  storagePath: any | null;
+  service: "local-storage";
+  type: TypeStorage4;
+};
+
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type BucketNameSecretRef2 = {
+  key: string;
+  name: string;
+};
+
+export type BucketName2 = {
+  /**
+   * Reference to a Kubernetes Secret
+   */
+  secretRef: BucketNameSecretRef2;
+};
+
+export const TypeStorage3 = {
+  Storage: "storage",
+} as const;
+export type TypeStorage3 = ClosedEnum<typeof TypeStorage3>;
+
+/**
+ * Google Cloud Storage binding configuration
+ */
+export type ExternalBindingGcs = {
+  /**
+   * Represents a value that can be either a concrete value, a template expression,
+   *
+   * @remarks
+   * or a reference to a Kubernetes Secret
+   */
+  bucketName: any | null;
+  service: "gcs";
+  type: TypeStorage3;
+};
+
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type AccountNameSecretRef1 = {
+  key: string;
+  name: string;
+};
+
+export type AccountName1 = {
+  /**
+   * Reference to a Kubernetes Secret
+   */
+  secretRef: AccountNameSecretRef1;
+};
+
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type ContainerNameSecretRef = {
+  key: string;
+  name: string;
+};
+
+export type ContainerName = {
+  /**
+   * Reference to a Kubernetes Secret
+   */
+  secretRef: ContainerNameSecretRef;
+};
+
+export const TypeStorage2 = {
+  Storage: "storage",
+} as const;
+export type TypeStorage2 = ClosedEnum<typeof TypeStorage2>;
+
+/**
+ * Azure Blob Storage binding configuration
+ */
+export type ExternalBindingBlob = {
+  /**
+   * Represents a value that can be either a concrete value, a template expression,
+   *
+   * @remarks
+   * or a reference to a Kubernetes Secret
+   */
+  accountName: any | null;
+  /**
+   * Represents a value that can be either a concrete value, a template expression,
+   *
+   * @remarks
+   * or a reference to a Kubernetes Secret
+   */
+  containerName: any | null;
+  service: "blob";
+  type: TypeStorage2;
+};
+
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type AccessKeyIdSecretRef = {
+  key: string;
+  name: string;
+};
+
+export type AccessKeyId = {
+  /**
+   * Reference to a Kubernetes Secret
+   */
+  secretRef: AccessKeyIdSecretRef;
+};
+
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type BucketNameSecretRef1 = {
+  key: string;
+  name: string;
+};
+
+export type BucketName1 = {
+  /**
+   * Reference to a Kubernetes Secret
+   */
+  secretRef: BucketNameSecretRef1;
+};
+
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type EndpointSecretRef = {
+  key: string;
+  name: string;
+};
+
+export type ExternalBindingEndpoint = {
+  /**
+   * Reference to a Kubernetes Secret
+   */
+  secretRef: EndpointSecretRef;
+};
+
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type RegionSecretRef1 = {
+  key: string;
+  name: string;
+};
+
+export type Region1 = {
+  /**
+   * Reference to a Kubernetes Secret
+   */
+  secretRef: RegionSecretRef1;
+};
+
+/**
+ * Reference to a Kubernetes Secret
+ */
+export type SecretAccessKeySecretRef = {
+  key: string;
+  name: string;
+};
+
+export type SecretAccessKey = {
+  /**
+   * Reference to a Kubernetes Secret
+   */
+  secretRef: SecretAccessKeySecretRef;
+};
+
+export const TypeStorage1 = {
+  Storage: "storage",
+} as const;
+export type TypeStorage1 = ClosedEnum<typeof TypeStorage1>;
+
+/**
+ * S3 storage binding configuration.
+ *
+ * @remarks
+ *
+ * Targets AWS S3 by default. Setting `endpoint` targets any S3-compatible
+ * store instead (MinIO, Ceph RGW, NetApp StorageGRID, Cloudflare R2, ...),
+ * which is how Kubernetes deployments outside a cloud account attach the
+ * customer's existing object storage.
+ */
+export type ExternalBindingS3 = {
+  accessKeyId?: any | null | undefined;
+  /**
+   * Represents a value that can be either a concrete value, a template expression,
+   *
+   * @remarks
+   * or a reference to a Kubernetes Secret
+   */
+  bucketName: any | null;
+  endpoint?: any | null | undefined;
+  /**
+   * Use path-style URLs (`endpoint/bucket/key`) instead of virtual-hosted
+   *
+   * @remarks
+   * ones (`bucket.endpoint/key`). Defaults to `true` when `endpoint` is
+   * set, since most S3-compatible stores require it.
+   */
+  forcePathStyle?: boolean | null | undefined;
+  region?: any | null | undefined;
+  secretAccessKey?: any | null | undefined;
+  service: "s3";
+  type: TypeStorage1;
+};
+
+/**
+ * Service-type based storage binding that supports multiple storage providers
+ */
+export type ExternalBindingUnion1 =
+  | ExternalBindingS3
+  | ExternalBindingBlob
+  | ExternalBindingGcs
+  | ExternalBindingLocalStorage;
+
+/**
+ * Represents a binding to pre-existing infrastructure.
+ *
+ * @remarks
+ *
+ * The binding type must match the resource type it's applied to.
+ * Validated at runtime by the executor.
+ */
+export type ExternalBindingUnion =
+  | ExternalBindingContainerAppsEnvironment
+  | ExternalBindingAi
+  | ExternalBindingS3
+  | ExternalBindingBlob
+  | ExternalBindingGcs
+  | ExternalBindingLocalStorage
+  | ExternalBindingSqs
+  | ExternalBindingPubsub
+  | ExternalBindingServicebus
+  | ExternalBindingLocalQueue
+  | ExternalBindingDynamodb
+  | ExternalBindingFirestore
+  | ExternalBindingTablestorage
+  | ExternalBindingRedis
+  | ExternalBindingLocalKv
+  | ExternalBindingUnion4
+  | ExternalBindingUnion5
+  | ExternalBindingUnion6;
+
+/** @internal */
+export const ExternalBindingRedis$inboundSchema: z.ZodType<
+  ExternalBindingRedis,
+  unknown
+> = z.object({
+  connectionUrl: z.nullable(z.any()),
+  database: z.nullable(DatabaseUnion$inboundSchema).optional(),
+  keyPrefix: z.nullable(z.any()).optional(),
+  service: z.literal("redis"),
+  type: TypeKv4$inboundSchema,
+});
+/** @internal */
+export type ExternalBindingRedis$Outbound = {
+  connectionUrl: any | null;
+  database?: DatabaseUnion$Outbound | null | undefined;
+  keyPrefix?: any | null | undefined;
+  service: "redis";
+  type: string;
+};
+
+/** @internal */
+export const ExternalBindingRedis$outboundSchema: z.ZodType<
+  ExternalBindingRedis$Outbound,
+  ExternalBindingRedis
+> = z.object({
+  connectionUrl: z.nullable(z.any()),
+  database: z.nullable(DatabaseUnion$outboundSchema).optional(),
+  keyPrefix: z.nullable(z.any()).optional(),
+  service: z.literal("redis"),
+  type: TypeKv4$outboundSchema,
+});
+
+export function externalBindingRedisToJSON(
+  externalBindingRedis: ExternalBindingRedis,
+): string {
+  return JSON.stringify(
+    ExternalBindingRedis$outboundSchema.parse(externalBindingRedis),
+  );
+}
+export function externalBindingRedisFromJSON(
+  jsonString: string,
+): SafeParseResult<ExternalBindingRedis, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ExternalBindingRedis$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExternalBindingRedis' from JSON`,
+  );
+}
+
+/** @internal */
+export const AccountNameSecretRef2$inboundSchema: z.ZodType<
+  AccountNameSecretRef2,
+  unknown
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+/** @internal */
+export type AccountNameSecretRef2$Outbound = {
+  key: string;
+  name: string;
+};
+
+/** @internal */
+export const AccountNameSecretRef2$outboundSchema: z.ZodType<
+  AccountNameSecretRef2$Outbound,
+  AccountNameSecretRef2
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+
+export function accountNameSecretRef2ToJSON(
+  accountNameSecretRef2: AccountNameSecretRef2,
+): string {
+  return JSON.stringify(
+    AccountNameSecretRef2$outboundSchema.parse(accountNameSecretRef2),
+  );
+}
+export function accountNameSecretRef2FromJSON(
+  jsonString: string,
+): SafeParseResult<AccountNameSecretRef2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AccountNameSecretRef2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AccountNameSecretRef2' from JSON`,
+  );
+}
+
+/** @internal */
+export const AccountName2$inboundSchema: z.ZodType<AccountName2, unknown> = z
+  .object({
+    secretRef: z.lazy(() => AccountNameSecretRef2$inboundSchema),
+  });
+/** @internal */
+export type AccountName2$Outbound = {
+  secretRef: AccountNameSecretRef2$Outbound;
+};
+
+/** @internal */
+export const AccountName2$outboundSchema: z.ZodType<
+  AccountName2$Outbound,
+  AccountName2
+> = z.object({
+  secretRef: z.lazy(() => AccountNameSecretRef2$outboundSchema),
+});
+
+export function accountName2ToJSON(accountName2: AccountName2): string {
+  return JSON.stringify(AccountName2$outboundSchema.parse(accountName2));
+}
+export function accountName2FromJSON(
+  jsonString: string,
+): SafeParseResult<AccountName2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AccountName2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AccountName2' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResourceGroupNameSecretRef1$inboundSchema: z.ZodType<
+  ResourceGroupNameSecretRef1,
+  unknown
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+/** @internal */
+export type ResourceGroupNameSecretRef1$Outbound = {
+  key: string;
+  name: string;
+};
+
+/** @internal */
+export const ResourceGroupNameSecretRef1$outboundSchema: z.ZodType<
+  ResourceGroupNameSecretRef1$Outbound,
+  ResourceGroupNameSecretRef1
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+
+export function resourceGroupNameSecretRef1ToJSON(
+  resourceGroupNameSecretRef1: ResourceGroupNameSecretRef1,
+): string {
+  return JSON.stringify(
+    ResourceGroupNameSecretRef1$outboundSchema.parse(
+      resourceGroupNameSecretRef1,
+    ),
+  );
+}
+export function resourceGroupNameSecretRef1FromJSON(
+  jsonString: string,
+): SafeParseResult<ResourceGroupNameSecretRef1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResourceGroupNameSecretRef1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResourceGroupNameSecretRef1' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResourceGroupName1$inboundSchema: z.ZodType<
+  ResourceGroupName1,
+  unknown
+> = z.object({
+  secretRef: z.lazy(() => ResourceGroupNameSecretRef1$inboundSchema),
+});
+/** @internal */
+export type ResourceGroupName1$Outbound = {
+  secretRef: ResourceGroupNameSecretRef1$Outbound;
+};
+
+/** @internal */
+export const ResourceGroupName1$outboundSchema: z.ZodType<
+  ResourceGroupName1$Outbound,
+  ResourceGroupName1
+> = z.object({
+  secretRef: z.lazy(() => ResourceGroupNameSecretRef1$outboundSchema),
+});
+
+export function resourceGroupName1ToJSON(
+  resourceGroupName1: ResourceGroupName1,
+): string {
+  return JSON.stringify(
+    ResourceGroupName1$outboundSchema.parse(resourceGroupName1),
+  );
+}
+export function resourceGroupName1FromJSON(
+  jsonString: string,
+): SafeParseResult<ResourceGroupName1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResourceGroupName1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResourceGroupName1' from JSON`,
+  );
+}
+
+/** @internal */
+export const TableNameSecretRef2$inboundSchema: z.ZodType<
+  TableNameSecretRef2,
+  unknown
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+/** @internal */
+export type TableNameSecretRef2$Outbound = {
+  key: string;
+  name: string;
+};
+
+/** @internal */
+export const TableNameSecretRef2$outboundSchema: z.ZodType<
+  TableNameSecretRef2$Outbound,
+  TableNameSecretRef2
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+
+export function tableNameSecretRef2ToJSON(
+  tableNameSecretRef2: TableNameSecretRef2,
+): string {
+  return JSON.stringify(
+    TableNameSecretRef2$outboundSchema.parse(tableNameSecretRef2),
+  );
+}
+export function tableNameSecretRef2FromJSON(
+  jsonString: string,
+): SafeParseResult<TableNameSecretRef2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TableNameSecretRef2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TableNameSecretRef2' from JSON`,
+  );
+}
+
+/** @internal */
+export const TableName2$inboundSchema: z.ZodType<TableName2, unknown> = z
+  .object({
+    secretRef: z.lazy(() => TableNameSecretRef2$inboundSchema),
+  });
+/** @internal */
+export type TableName2$Outbound = {
+  secretRef: TableNameSecretRef2$Outbound;
+};
+
+/** @internal */
+export const TableName2$outboundSchema: z.ZodType<
+  TableName2$Outbound,
+  TableName2
+> = z.object({
+  secretRef: z.lazy(() => TableNameSecretRef2$outboundSchema),
+});
+
+export function tableName2ToJSON(tableName2: TableName2): string {
+  return JSON.stringify(TableName2$outboundSchema.parse(tableName2));
+}
+export function tableName2FromJSON(
+  jsonString: string,
+): SafeParseResult<TableName2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TableName2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TableName2' from JSON`,
+  );
+}
+
+/** @internal */
+export const TypeKv3$inboundSchema: z.ZodEnum<typeof TypeKv3> = z.enum(TypeKv3);
+/** @internal */
+export const TypeKv3$outboundSchema: z.ZodEnum<typeof TypeKv3> =
+  TypeKv3$inboundSchema;
+
+/** @internal */
+export const ExternalBindingTablestorage$inboundSchema: z.ZodType<
+  ExternalBindingTablestorage,
+  unknown
+> = z.object({
+  accountName: z.nullable(z.any()),
+  resourceGroupName: z.nullable(z.any()),
+  tableName: z.nullable(z.any()),
+  service: z.literal("tablestorage"),
+  type: TypeKv3$inboundSchema,
+});
+/** @internal */
+export type ExternalBindingTablestorage$Outbound = {
+  accountName: any | null;
+  resourceGroupName: any | null;
+  tableName: any | null;
+  service: "tablestorage";
+  type: string;
+};
+
+/** @internal */
+export const ExternalBindingTablestorage$outboundSchema: z.ZodType<
+  ExternalBindingTablestorage$Outbound,
+  ExternalBindingTablestorage
+> = z.object({
+  accountName: z.nullable(z.any()),
+  resourceGroupName: z.nullable(z.any()),
+  tableName: z.nullable(z.any()),
+  service: z.literal("tablestorage"),
+  type: TypeKv3$outboundSchema,
+});
+
+export function externalBindingTablestorageToJSON(
+  externalBindingTablestorage: ExternalBindingTablestorage,
+): string {
+  return JSON.stringify(
+    ExternalBindingTablestorage$outboundSchema.parse(
+      externalBindingTablestorage,
+    ),
+  );
+}
+export function externalBindingTablestorageFromJSON(
+  jsonString: string,
+): SafeParseResult<ExternalBindingTablestorage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ExternalBindingTablestorage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExternalBindingTablestorage' from JSON`,
+  );
+}
+
+/** @internal */
+export const CollectionNameSecretRef$inboundSchema: z.ZodType<
+  CollectionNameSecretRef,
+  unknown
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+/** @internal */
+export type CollectionNameSecretRef$Outbound = {
+  key: string;
+  name: string;
+};
+
+/** @internal */
+export const CollectionNameSecretRef$outboundSchema: z.ZodType<
+  CollectionNameSecretRef$Outbound,
+  CollectionNameSecretRef
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+
+export function collectionNameSecretRefToJSON(
+  collectionNameSecretRef: CollectionNameSecretRef,
+): string {
+  return JSON.stringify(
+    CollectionNameSecretRef$outboundSchema.parse(collectionNameSecretRef),
+  );
+}
+export function collectionNameSecretRefFromJSON(
+  jsonString: string,
+): SafeParseResult<CollectionNameSecretRef, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CollectionNameSecretRef$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CollectionNameSecretRef' from JSON`,
+  );
+}
+
+/** @internal */
+export const CollectionName$inboundSchema: z.ZodType<CollectionName, unknown> =
+  z.object({
+    secretRef: z.lazy(() => CollectionNameSecretRef$inboundSchema),
+  });
+/** @internal */
+export type CollectionName$Outbound = {
+  secretRef: CollectionNameSecretRef$Outbound;
+};
+
+/** @internal */
+export const CollectionName$outboundSchema: z.ZodType<
+  CollectionName$Outbound,
+  CollectionName
+> = z.object({
+  secretRef: z.lazy(() => CollectionNameSecretRef$outboundSchema),
+});
+
+export function collectionNameToJSON(collectionName: CollectionName): string {
+  return JSON.stringify(CollectionName$outboundSchema.parse(collectionName));
+}
+export function collectionNameFromJSON(
+  jsonString: string,
+): SafeParseResult<CollectionName, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CollectionName$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CollectionName' from JSON`,
+  );
+}
+
+/** @internal */
+export const DatabaseIdSecretRef$inboundSchema: z.ZodType<
+  DatabaseIdSecretRef,
+  unknown
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+/** @internal */
+export type DatabaseIdSecretRef$Outbound = {
+  key: string;
+  name: string;
+};
+
+/** @internal */
+export const DatabaseIdSecretRef$outboundSchema: z.ZodType<
+  DatabaseIdSecretRef$Outbound,
+  DatabaseIdSecretRef
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+
+export function databaseIdSecretRefToJSON(
+  databaseIdSecretRef: DatabaseIdSecretRef,
+): string {
+  return JSON.stringify(
+    DatabaseIdSecretRef$outboundSchema.parse(databaseIdSecretRef),
+  );
+}
+export function databaseIdSecretRefFromJSON(
+  jsonString: string,
+): SafeParseResult<DatabaseIdSecretRef, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DatabaseIdSecretRef$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DatabaseIdSecretRef' from JSON`,
+  );
+}
+
+/** @internal */
+export const DatabaseId$inboundSchema: z.ZodType<DatabaseId, unknown> = z
+  .object({
+    secretRef: z.lazy(() => DatabaseIdSecretRef$inboundSchema),
+  });
+/** @internal */
+export type DatabaseId$Outbound = {
+  secretRef: DatabaseIdSecretRef$Outbound;
+};
+
+/** @internal */
+export const DatabaseId$outboundSchema: z.ZodType<
+  DatabaseId$Outbound,
+  DatabaseId
+> = z.object({
+  secretRef: z.lazy(() => DatabaseIdSecretRef$outboundSchema),
+});
+
+export function databaseIdToJSON(databaseId: DatabaseId): string {
+  return JSON.stringify(DatabaseId$outboundSchema.parse(databaseId));
+}
+export function databaseIdFromJSON(
+  jsonString: string,
+): SafeParseResult<DatabaseId, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DatabaseId$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DatabaseId' from JSON`,
+  );
+}
+
+/** @internal */
+export const ProjectIdSecretRef$inboundSchema: z.ZodType<
+  ProjectIdSecretRef,
+  unknown
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+/** @internal */
+export type ProjectIdSecretRef$Outbound = {
+  key: string;
+  name: string;
+};
+
+/** @internal */
+export const ProjectIdSecretRef$outboundSchema: z.ZodType<
+  ProjectIdSecretRef$Outbound,
+  ProjectIdSecretRef
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+
+export function projectIdSecretRefToJSON(
+  projectIdSecretRef: ProjectIdSecretRef,
+): string {
+  return JSON.stringify(
+    ProjectIdSecretRef$outboundSchema.parse(projectIdSecretRef),
+  );
+}
+export function projectIdSecretRefFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectIdSecretRef, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProjectIdSecretRef$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectIdSecretRef' from JSON`,
+  );
+}
+
+/** @internal */
+export const ProjectId$inboundSchema: z.ZodType<ProjectId, unknown> = z.object({
+  secretRef: z.lazy(() => ProjectIdSecretRef$inboundSchema),
+});
+/** @internal */
+export type ProjectId$Outbound = {
+  secretRef: ProjectIdSecretRef$Outbound;
+};
+
+/** @internal */
+export const ProjectId$outboundSchema: z.ZodType<
+  ProjectId$Outbound,
+  ProjectId
+> = z.object({
+  secretRef: z.lazy(() => ProjectIdSecretRef$outboundSchema),
+});
+
+export function projectIdToJSON(projectId: ProjectId): string {
+  return JSON.stringify(ProjectId$outboundSchema.parse(projectId));
+}
+export function projectIdFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectId, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProjectId$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectId' from JSON`,
+  );
+}
+
+/** @internal */
+export const TypeKv2$inboundSchema: z.ZodEnum<typeof TypeKv2> = z.enum(TypeKv2);
+/** @internal */
+export const TypeKv2$outboundSchema: z.ZodEnum<typeof TypeKv2> =
+  TypeKv2$inboundSchema;
+
+/** @internal */
+export const ExternalBindingFirestore$inboundSchema: z.ZodType<
+  ExternalBindingFirestore,
+  unknown
+> = z.object({
+  collectionName: z.nullable(z.any()),
+  databaseId: z.nullable(z.any()),
+  projectId: z.nullable(z.any()),
+  service: z.literal("firestore"),
+  type: TypeKv2$inboundSchema,
+});
+/** @internal */
+export type ExternalBindingFirestore$Outbound = {
+  collectionName: any | null;
+  databaseId: any | null;
+  projectId: any | null;
+  service: "firestore";
+  type: string;
+};
+
+/** @internal */
+export const ExternalBindingFirestore$outboundSchema: z.ZodType<
+  ExternalBindingFirestore$Outbound,
+  ExternalBindingFirestore
+> = z.object({
+  collectionName: z.nullable(z.any()),
+  databaseId: z.nullable(z.any()),
+  projectId: z.nullable(z.any()),
+  service: z.literal("firestore"),
+  type: TypeKv2$outboundSchema,
+});
+
+export function externalBindingFirestoreToJSON(
+  externalBindingFirestore: ExternalBindingFirestore,
+): string {
+  return JSON.stringify(
+    ExternalBindingFirestore$outboundSchema.parse(externalBindingFirestore),
+  );
+}
+export function externalBindingFirestoreFromJSON(
+  jsonString: string,
+): SafeParseResult<ExternalBindingFirestore, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ExternalBindingFirestore$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExternalBindingFirestore' from JSON`,
+  );
+}
+
+/** @internal */
+export const EndpointUrlSecretRef$inboundSchema: z.ZodType<
+  EndpointUrlSecretRef,
+  unknown
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+/** @internal */
+export type EndpointUrlSecretRef$Outbound = {
+  key: string;
+  name: string;
+};
+
+/** @internal */
+export const EndpointUrlSecretRef$outboundSchema: z.ZodType<
+  EndpointUrlSecretRef$Outbound,
+  EndpointUrlSecretRef
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+
+export function endpointUrlSecretRefToJSON(
+  endpointUrlSecretRef: EndpointUrlSecretRef,
+): string {
+  return JSON.stringify(
+    EndpointUrlSecretRef$outboundSchema.parse(endpointUrlSecretRef),
+  );
+}
+export function endpointUrlSecretRefFromJSON(
+  jsonString: string,
+): SafeParseResult<EndpointUrlSecretRef, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EndpointUrlSecretRef$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EndpointUrlSecretRef' from JSON`,
+  );
+}
+
+/** @internal */
+export const EndpointUrl$inboundSchema: z.ZodType<EndpointUrl, unknown> = z
+  .object({
+    secretRef: z.lazy(() => EndpointUrlSecretRef$inboundSchema),
+  });
+/** @internal */
+export type EndpointUrl$Outbound = {
+  secretRef: EndpointUrlSecretRef$Outbound;
+};
+
+/** @internal */
+export const EndpointUrl$outboundSchema: z.ZodType<
+  EndpointUrl$Outbound,
+  EndpointUrl
+> = z.object({
+  secretRef: z.lazy(() => EndpointUrlSecretRef$outboundSchema),
+});
+
+export function endpointUrlToJSON(endpointUrl: EndpointUrl): string {
+  return JSON.stringify(EndpointUrl$outboundSchema.parse(endpointUrl));
+}
+export function endpointUrlFromJSON(
+  jsonString: string,
+): SafeParseResult<EndpointUrl, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EndpointUrl$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EndpointUrl' from JSON`,
+  );
+}
+
+/** @internal */
+export const RegionSecretRef2$inboundSchema: z.ZodType<
+  RegionSecretRef2,
+  unknown
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+/** @internal */
+export type RegionSecretRef2$Outbound = {
+  key: string;
+  name: string;
+};
+
+/** @internal */
+export const RegionSecretRef2$outboundSchema: z.ZodType<
+  RegionSecretRef2$Outbound,
+  RegionSecretRef2
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+
+export function regionSecretRef2ToJSON(
+  regionSecretRef2: RegionSecretRef2,
+): string {
+  return JSON.stringify(
+    RegionSecretRef2$outboundSchema.parse(regionSecretRef2),
+  );
+}
+export function regionSecretRef2FromJSON(
+  jsonString: string,
+): SafeParseResult<RegionSecretRef2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RegionSecretRef2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RegionSecretRef2' from JSON`,
+  );
+}
+
+/** @internal */
+export const Region2$inboundSchema: z.ZodType<Region2, unknown> = z.object({
+  secretRef: z.lazy(() => RegionSecretRef2$inboundSchema),
+});
+/** @internal */
+export type Region2$Outbound = {
+  secretRef: RegionSecretRef2$Outbound;
+};
+
+/** @internal */
+export const Region2$outboundSchema: z.ZodType<Region2$Outbound, Region2> = z
+  .object({
+    secretRef: z.lazy(() => RegionSecretRef2$outboundSchema),
+  });
+
+export function region2ToJSON(region2: Region2): string {
+  return JSON.stringify(Region2$outboundSchema.parse(region2));
+}
+export function region2FromJSON(
+  jsonString: string,
+): SafeParseResult<Region2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Region2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Region2' from JSON`,
+  );
+}
+
+/** @internal */
+export const TableNameSecretRef1$inboundSchema: z.ZodType<
+  TableNameSecretRef1,
+  unknown
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+/** @internal */
+export type TableNameSecretRef1$Outbound = {
+  key: string;
+  name: string;
+};
+
+/** @internal */
+export const TableNameSecretRef1$outboundSchema: z.ZodType<
+  TableNameSecretRef1$Outbound,
+  TableNameSecretRef1
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+
+export function tableNameSecretRef1ToJSON(
+  tableNameSecretRef1: TableNameSecretRef1,
+): string {
+  return JSON.stringify(
+    TableNameSecretRef1$outboundSchema.parse(tableNameSecretRef1),
+  );
+}
+export function tableNameSecretRef1FromJSON(
+  jsonString: string,
+): SafeParseResult<TableNameSecretRef1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TableNameSecretRef1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TableNameSecretRef1' from JSON`,
+  );
+}
+
+/** @internal */
+export const TableName1$inboundSchema: z.ZodType<TableName1, unknown> = z
+  .object({
+    secretRef: z.lazy(() => TableNameSecretRef1$inboundSchema),
+  });
+/** @internal */
+export type TableName1$Outbound = {
+  secretRef: TableNameSecretRef1$Outbound;
+};
+
+/** @internal */
+export const TableName1$outboundSchema: z.ZodType<
+  TableName1$Outbound,
+  TableName1
+> = z.object({
+  secretRef: z.lazy(() => TableNameSecretRef1$outboundSchema),
+});
+
+export function tableName1ToJSON(tableName1: TableName1): string {
+  return JSON.stringify(TableName1$outboundSchema.parse(tableName1));
+}
+export function tableName1FromJSON(
+  jsonString: string,
+): SafeParseResult<TableName1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TableName1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TableName1' from JSON`,
+  );
+}
+
+/** @internal */
+export const TypeKv1$inboundSchema: z.ZodEnum<typeof TypeKv1> = z.enum(TypeKv1);
+/** @internal */
+export const TypeKv1$outboundSchema: z.ZodEnum<typeof TypeKv1> =
+  TypeKv1$inboundSchema;
+
+/** @internal */
+export const ExternalBindingDynamodb$inboundSchema: z.ZodType<
+  ExternalBindingDynamodb,
+  unknown
+> = z.object({
+  endpointUrl: z.nullable(z.any()).optional(),
+  region: z.nullable(z.any()),
+  tableName: z.nullable(z.any()),
+  service: z.literal("dynamodb"),
+  type: TypeKv1$inboundSchema,
+});
+/** @internal */
+export type ExternalBindingDynamodb$Outbound = {
+  endpointUrl?: any | null | undefined;
+  region: any | null;
+  tableName: any | null;
+  service: "dynamodb";
+  type: string;
+};
+
+/** @internal */
+export const ExternalBindingDynamodb$outboundSchema: z.ZodType<
+  ExternalBindingDynamodb$Outbound,
+  ExternalBindingDynamodb
+> = z.object({
+  endpointUrl: z.nullable(z.any()).optional(),
+  region: z.nullable(z.any()),
+  tableName: z.nullable(z.any()),
+  service: z.literal("dynamodb"),
+  type: TypeKv1$outboundSchema,
+});
+
+export function externalBindingDynamodbToJSON(
+  externalBindingDynamodb: ExternalBindingDynamodb,
+): string {
+  return JSON.stringify(
+    ExternalBindingDynamodb$outboundSchema.parse(externalBindingDynamodb),
+  );
+}
+export function externalBindingDynamodbFromJSON(
+  jsonString: string,
+): SafeParseResult<ExternalBindingDynamodb, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ExternalBindingDynamodb$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExternalBindingDynamodb' from JSON`,
+  );
+}
+
+/** @internal */
+export const ExternalBindingUnion3$inboundSchema: z.ZodType<
+  ExternalBindingUnion3,
+  unknown
+> = z.union([
+  z.lazy(() => ExternalBindingDynamodb$inboundSchema),
+  z.lazy(() => ExternalBindingFirestore$inboundSchema),
+  z.lazy(() => ExternalBindingTablestorage$inboundSchema),
+  z.lazy(() => ExternalBindingRedis$inboundSchema),
+  ExternalBindingLocalKv$inboundSchema,
+]);
+/** @internal */
+export type ExternalBindingUnion3$Outbound =
+  | ExternalBindingDynamodb$Outbound
+  | ExternalBindingFirestore$Outbound
+  | ExternalBindingTablestorage$Outbound
+  | ExternalBindingRedis$Outbound
+  | ExternalBindingLocalKv$Outbound;
+
+/** @internal */
+export const ExternalBindingUnion3$outboundSchema: z.ZodType<
+  ExternalBindingUnion3$Outbound,
+  ExternalBindingUnion3
+> = z.union([
+  z.lazy(() => ExternalBindingDynamodb$outboundSchema),
+  z.lazy(() => ExternalBindingFirestore$outboundSchema),
+  z.lazy(() => ExternalBindingTablestorage$outboundSchema),
+  z.lazy(() => ExternalBindingRedis$outboundSchema),
+  ExternalBindingLocalKv$outboundSchema,
+]);
+
+export function externalBindingUnion3ToJSON(
+  externalBindingUnion3: ExternalBindingUnion3,
+): string {
+  return JSON.stringify(
+    ExternalBindingUnion3$outboundSchema.parse(externalBindingUnion3),
+  );
+}
+export function externalBindingUnion3FromJSON(
+  jsonString: string,
+): SafeParseResult<ExternalBindingUnion3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ExternalBindingUnion3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExternalBindingUnion3' from JSON`,
+  );
+}
+
+/** @internal */
+export const QueuePathSecretRef$inboundSchema: z.ZodType<
+  QueuePathSecretRef,
+  unknown
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+/** @internal */
+export type QueuePathSecretRef$Outbound = {
+  key: string;
+  name: string;
+};
+
+/** @internal */
+export const QueuePathSecretRef$outboundSchema: z.ZodType<
+  QueuePathSecretRef$Outbound,
+  QueuePathSecretRef
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+
+export function queuePathSecretRefToJSON(
+  queuePathSecretRef: QueuePathSecretRef,
+): string {
+  return JSON.stringify(
+    QueuePathSecretRef$outboundSchema.parse(queuePathSecretRef),
+  );
+}
+export function queuePathSecretRefFromJSON(
+  jsonString: string,
+): SafeParseResult<QueuePathSecretRef, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QueuePathSecretRef$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QueuePathSecretRef' from JSON`,
+  );
+}
+
+/** @internal */
+export const QueuePath$inboundSchema: z.ZodType<QueuePath, unknown> = z.object({
+  secretRef: z.lazy(() => QueuePathSecretRef$inboundSchema),
+});
+/** @internal */
+export type QueuePath$Outbound = {
+  secretRef: QueuePathSecretRef$Outbound;
+};
+
+/** @internal */
+export const QueuePath$outboundSchema: z.ZodType<
+  QueuePath$Outbound,
+  QueuePath
+> = z.object({
+  secretRef: z.lazy(() => QueuePathSecretRef$outboundSchema),
+});
+
+export function queuePathToJSON(queuePath: QueuePath): string {
+  return JSON.stringify(QueuePath$outboundSchema.parse(queuePath));
+}
+export function queuePathFromJSON(
+  jsonString: string,
+): SafeParseResult<QueuePath, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QueuePath$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QueuePath' from JSON`,
+  );
+}
+
+/** @internal */
+export const TypeQueue4$inboundSchema: z.ZodEnum<typeof TypeQueue4> = z.enum(
+  TypeQueue4,
+);
+/** @internal */
+export const TypeQueue4$outboundSchema: z.ZodEnum<typeof TypeQueue4> =
+  TypeQueue4$inboundSchema;
+
+/** @internal */
+export const ExternalBindingLocalQueue$inboundSchema: z.ZodType<
+  ExternalBindingLocalQueue,
+  unknown
+> = z.object({
+  queuePath: z.nullable(z.any()),
+  service: z.literal("local-queue"),
+  type: TypeQueue4$inboundSchema,
+});
+/** @internal */
+export type ExternalBindingLocalQueue$Outbound = {
+  queuePath: any | null;
+  service: "local-queue";
+  type: string;
+};
+
+/** @internal */
+export const ExternalBindingLocalQueue$outboundSchema: z.ZodType<
+  ExternalBindingLocalQueue$Outbound,
+  ExternalBindingLocalQueue
+> = z.object({
+  queuePath: z.nullable(z.any()),
+  service: z.literal("local-queue"),
+  type: TypeQueue4$outboundSchema,
+});
+
+export function externalBindingLocalQueueToJSON(
+  externalBindingLocalQueue: ExternalBindingLocalQueue,
+): string {
+  return JSON.stringify(
+    ExternalBindingLocalQueue$outboundSchema.parse(externalBindingLocalQueue),
+  );
+}
+export function externalBindingLocalQueueFromJSON(
+  jsonString: string,
+): SafeParseResult<ExternalBindingLocalQueue, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ExternalBindingLocalQueue$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExternalBindingLocalQueue' from JSON`,
+  );
+}
+
+/** @internal */
+export const NamespaceSecretRef1$inboundSchema: z.ZodType<
+  NamespaceSecretRef1,
+  unknown
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+/** @internal */
+export type NamespaceSecretRef1$Outbound = {
+  key: string;
+  name: string;
+};
+
+/** @internal */
+export const NamespaceSecretRef1$outboundSchema: z.ZodType<
+  NamespaceSecretRef1$Outbound,
+  NamespaceSecretRef1
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+
+export function namespaceSecretRef1ToJSON(
+  namespaceSecretRef1: NamespaceSecretRef1,
+): string {
+  return JSON.stringify(
+    NamespaceSecretRef1$outboundSchema.parse(namespaceSecretRef1),
+  );
+}
+export function namespaceSecretRef1FromJSON(
+  jsonString: string,
+): SafeParseResult<NamespaceSecretRef1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => NamespaceSecretRef1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'NamespaceSecretRef1' from JSON`,
+  );
+}
+
+/** @internal */
+export const Namespace1$inboundSchema: z.ZodType<Namespace1, unknown> = z
+  .object({
+    secretRef: z.lazy(() => NamespaceSecretRef1$inboundSchema),
+  });
+/** @internal */
+export type Namespace1$Outbound = {
+  secretRef: NamespaceSecretRef1$Outbound;
+};
+
+/** @internal */
+export const Namespace1$outboundSchema: z.ZodType<
+  Namespace1$Outbound,
+  Namespace1
+> = z.object({
+  secretRef: z.lazy(() => NamespaceSecretRef1$outboundSchema),
+});
+
+export function namespace1ToJSON(namespace1: Namespace1): string {
+  return JSON.stringify(Namespace1$outboundSchema.parse(namespace1));
+}
+export function namespace1FromJSON(
+  jsonString: string,
+): SafeParseResult<Namespace1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Namespace1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Namespace1' from JSON`,
+  );
+}
+
+/** @internal */
+export const QueueNameSecretRef$inboundSchema: z.ZodType<
+  QueueNameSecretRef,
+  unknown
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+/** @internal */
+export type QueueNameSecretRef$Outbound = {
+  key: string;
+  name: string;
+};
+
+/** @internal */
+export const QueueNameSecretRef$outboundSchema: z.ZodType<
+  QueueNameSecretRef$Outbound,
+  QueueNameSecretRef
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+
+export function queueNameSecretRefToJSON(
+  queueNameSecretRef: QueueNameSecretRef,
+): string {
+  return JSON.stringify(
+    QueueNameSecretRef$outboundSchema.parse(queueNameSecretRef),
+  );
+}
+export function queueNameSecretRefFromJSON(
+  jsonString: string,
+): SafeParseResult<QueueNameSecretRef, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QueueNameSecretRef$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QueueNameSecretRef' from JSON`,
+  );
+}
+
+/** @internal */
+export const QueueName$inboundSchema: z.ZodType<QueueName, unknown> = z.object({
+  secretRef: z.lazy(() => QueueNameSecretRef$inboundSchema),
+});
+/** @internal */
+export type QueueName$Outbound = {
+  secretRef: QueueNameSecretRef$Outbound;
+};
+
+/** @internal */
+export const QueueName$outboundSchema: z.ZodType<
+  QueueName$Outbound,
+  QueueName
+> = z.object({
+  secretRef: z.lazy(() => QueueNameSecretRef$outboundSchema),
+});
+
+export function queueNameToJSON(queueName: QueueName): string {
+  return JSON.stringify(QueueName$outboundSchema.parse(queueName));
+}
+export function queueNameFromJSON(
+  jsonString: string,
+): SafeParseResult<QueueName, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QueueName$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QueueName' from JSON`,
+  );
+}
+
+/** @internal */
+export const TypeQueue3$inboundSchema: z.ZodEnum<typeof TypeQueue3> = z.enum(
+  TypeQueue3,
+);
+/** @internal */
+export const TypeQueue3$outboundSchema: z.ZodEnum<typeof TypeQueue3> =
+  TypeQueue3$inboundSchema;
+
+/** @internal */
+export const ExternalBindingServicebus$inboundSchema: z.ZodType<
+  ExternalBindingServicebus,
+  unknown
+> = z.object({
+  namespace: z.nullable(z.any()),
+  queueName: z.nullable(z.any()),
+  service: z.literal("servicebus"),
+  type: TypeQueue3$inboundSchema,
+});
+/** @internal */
+export type ExternalBindingServicebus$Outbound = {
+  namespace: any | null;
+  queueName: any | null;
+  service: "servicebus";
+  type: string;
+};
+
+/** @internal */
+export const ExternalBindingServicebus$outboundSchema: z.ZodType<
+  ExternalBindingServicebus$Outbound,
+  ExternalBindingServicebus
+> = z.object({
+  namespace: z.nullable(z.any()),
+  queueName: z.nullable(z.any()),
+  service: z.literal("servicebus"),
+  type: TypeQueue3$outboundSchema,
+});
+
+export function externalBindingServicebusToJSON(
+  externalBindingServicebus: ExternalBindingServicebus,
+): string {
+  return JSON.stringify(
+    ExternalBindingServicebus$outboundSchema.parse(externalBindingServicebus),
+  );
+}
+export function externalBindingServicebusFromJSON(
+  jsonString: string,
+): SafeParseResult<ExternalBindingServicebus, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ExternalBindingServicebus$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExternalBindingServicebus' from JSON`,
+  );
+}
+
+/** @internal */
+export const SubscriptionSecretRef$inboundSchema: z.ZodType<
+  SubscriptionSecretRef,
+  unknown
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+/** @internal */
+export type SubscriptionSecretRef$Outbound = {
+  key: string;
+  name: string;
+};
+
+/** @internal */
+export const SubscriptionSecretRef$outboundSchema: z.ZodType<
+  SubscriptionSecretRef$Outbound,
+  SubscriptionSecretRef
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+
+export function subscriptionSecretRefToJSON(
+  subscriptionSecretRef: SubscriptionSecretRef,
+): string {
+  return JSON.stringify(
+    SubscriptionSecretRef$outboundSchema.parse(subscriptionSecretRef),
+  );
+}
+export function subscriptionSecretRefFromJSON(
+  jsonString: string,
+): SafeParseResult<SubscriptionSecretRef, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SubscriptionSecretRef$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SubscriptionSecretRef' from JSON`,
+  );
+}
+
+/** @internal */
+export const Subscription$inboundSchema: z.ZodType<Subscription, unknown> = z
+  .object({
+    secretRef: z.lazy(() => SubscriptionSecretRef$inboundSchema),
+  });
+/** @internal */
+export type Subscription$Outbound = {
+  secretRef: SubscriptionSecretRef$Outbound;
+};
+
+/** @internal */
+export const Subscription$outboundSchema: z.ZodType<
+  Subscription$Outbound,
+  Subscription
+> = z.object({
+  secretRef: z.lazy(() => SubscriptionSecretRef$outboundSchema),
+});
+
+export function subscriptionToJSON(subscription: Subscription): string {
+  return JSON.stringify(Subscription$outboundSchema.parse(subscription));
+}
+export function subscriptionFromJSON(
+  jsonString: string,
+): SafeParseResult<Subscription, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Subscription$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Subscription' from JSON`,
+  );
+}
+
+/** @internal */
+export const TopicSecretRef$inboundSchema: z.ZodType<TopicSecretRef, unknown> =
+  z.object({
+    key: z.string(),
+    name: z.string(),
+  });
+/** @internal */
+export type TopicSecretRef$Outbound = {
+  key: string;
+  name: string;
+};
+
+/** @internal */
+export const TopicSecretRef$outboundSchema: z.ZodType<
+  TopicSecretRef$Outbound,
+  TopicSecretRef
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+
+export function topicSecretRefToJSON(topicSecretRef: TopicSecretRef): string {
+  return JSON.stringify(TopicSecretRef$outboundSchema.parse(topicSecretRef));
+}
+export function topicSecretRefFromJSON(
+  jsonString: string,
+): SafeParseResult<TopicSecretRef, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TopicSecretRef$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TopicSecretRef' from JSON`,
+  );
+}
+
+/** @internal */
+export const Topic$inboundSchema: z.ZodType<Topic, unknown> = z.object({
+  secretRef: z.lazy(() => TopicSecretRef$inboundSchema),
+});
+/** @internal */
+export type Topic$Outbound = {
+  secretRef: TopicSecretRef$Outbound;
+};
+
+/** @internal */
+export const Topic$outboundSchema: z.ZodType<Topic$Outbound, Topic> = z.object({
+  secretRef: z.lazy(() => TopicSecretRef$outboundSchema),
+});
+
+export function topicToJSON(topic: Topic): string {
+  return JSON.stringify(Topic$outboundSchema.parse(topic));
+}
+export function topicFromJSON(
+  jsonString: string,
+): SafeParseResult<Topic, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Topic$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Topic' from JSON`,
+  );
+}
+
+/** @internal */
+export const TypeQueue2$inboundSchema: z.ZodEnum<typeof TypeQueue2> = z.enum(
+  TypeQueue2,
+);
+/** @internal */
+export const TypeQueue2$outboundSchema: z.ZodEnum<typeof TypeQueue2> =
+  TypeQueue2$inboundSchema;
+
+/** @internal */
+export const ExternalBindingPubsub$inboundSchema: z.ZodType<
+  ExternalBindingPubsub,
+  unknown
+> = z.object({
+  subscription: z.nullable(z.any()),
+  topic: z.nullable(z.any()),
+  service: z.literal("pubsub"),
+  type: TypeQueue2$inboundSchema,
+});
+/** @internal */
+export type ExternalBindingPubsub$Outbound = {
+  subscription: any | null;
+  topic: any | null;
+  service: "pubsub";
+  type: string;
+};
+
+/** @internal */
+export const ExternalBindingPubsub$outboundSchema: z.ZodType<
+  ExternalBindingPubsub$Outbound,
+  ExternalBindingPubsub
+> = z.object({
+  subscription: z.nullable(z.any()),
+  topic: z.nullable(z.any()),
+  service: z.literal("pubsub"),
+  type: TypeQueue2$outboundSchema,
+});
+
+export function externalBindingPubsubToJSON(
+  externalBindingPubsub: ExternalBindingPubsub,
+): string {
+  return JSON.stringify(
+    ExternalBindingPubsub$outboundSchema.parse(externalBindingPubsub),
+  );
+}
+export function externalBindingPubsubFromJSON(
+  jsonString: string,
+): SafeParseResult<ExternalBindingPubsub, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ExternalBindingPubsub$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExternalBindingPubsub' from JSON`,
+  );
+}
+
+/** @internal */
+export const QueueUrlSecretRef$inboundSchema: z.ZodType<
+  QueueUrlSecretRef,
+  unknown
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+/** @internal */
+export type QueueUrlSecretRef$Outbound = {
+  key: string;
+  name: string;
+};
+
+/** @internal */
+export const QueueUrlSecretRef$outboundSchema: z.ZodType<
+  QueueUrlSecretRef$Outbound,
+  QueueUrlSecretRef
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+
+export function queueUrlSecretRefToJSON(
+  queueUrlSecretRef: QueueUrlSecretRef,
+): string {
+  return JSON.stringify(
+    QueueUrlSecretRef$outboundSchema.parse(queueUrlSecretRef),
+  );
+}
+export function queueUrlSecretRefFromJSON(
+  jsonString: string,
+): SafeParseResult<QueueUrlSecretRef, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QueueUrlSecretRef$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QueueUrlSecretRef' from JSON`,
+  );
+}
+
+/** @internal */
+export const QueueUrl$inboundSchema: z.ZodType<QueueUrl, unknown> = z.object({
+  secretRef: z.lazy(() => QueueUrlSecretRef$inboundSchema),
+});
+/** @internal */
+export type QueueUrl$Outbound = {
+  secretRef: QueueUrlSecretRef$Outbound;
+};
+
+/** @internal */
+export const QueueUrl$outboundSchema: z.ZodType<QueueUrl$Outbound, QueueUrl> = z
+  .object({
+    secretRef: z.lazy(() => QueueUrlSecretRef$outboundSchema),
+  });
+
+export function queueUrlToJSON(queueUrl: QueueUrl): string {
+  return JSON.stringify(QueueUrl$outboundSchema.parse(queueUrl));
+}
+export function queueUrlFromJSON(
+  jsonString: string,
+): SafeParseResult<QueueUrl, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QueueUrl$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QueueUrl' from JSON`,
+  );
+}
+
+/** @internal */
+export const TypeQueue1$inboundSchema: z.ZodEnum<typeof TypeQueue1> = z.enum(
+  TypeQueue1,
+);
+/** @internal */
+export const TypeQueue1$outboundSchema: z.ZodEnum<typeof TypeQueue1> =
+  TypeQueue1$inboundSchema;
+
+/** @internal */
+export const ExternalBindingSqs$inboundSchema: z.ZodType<
+  ExternalBindingSqs,
+  unknown
+> = z.object({
+  queueUrl: z.nullable(z.any()),
+  service: z.literal("sqs"),
+  type: TypeQueue1$inboundSchema,
+});
+/** @internal */
+export type ExternalBindingSqs$Outbound = {
+  queueUrl: any | null;
+  service: "sqs";
+  type: string;
+};
+
+/** @internal */
+export const ExternalBindingSqs$outboundSchema: z.ZodType<
+  ExternalBindingSqs$Outbound,
+  ExternalBindingSqs
+> = z.object({
+  queueUrl: z.nullable(z.any()),
+  service: z.literal("sqs"),
+  type: TypeQueue1$outboundSchema,
+});
+
+export function externalBindingSqsToJSON(
+  externalBindingSqs: ExternalBindingSqs,
+): string {
+  return JSON.stringify(
+    ExternalBindingSqs$outboundSchema.parse(externalBindingSqs),
+  );
+}
+export function externalBindingSqsFromJSON(
+  jsonString: string,
+): SafeParseResult<ExternalBindingSqs, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ExternalBindingSqs$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExternalBindingSqs' from JSON`,
+  );
+}
+
+/** @internal */
+export const ExternalBindingUnion2$inboundSchema: z.ZodType<
+  ExternalBindingUnion2,
+  unknown
+> = z.union([
+  z.lazy(() => ExternalBindingSqs$inboundSchema),
+  z.lazy(() => ExternalBindingPubsub$inboundSchema),
+  z.lazy(() => ExternalBindingServicebus$inboundSchema),
+  z.lazy(() => ExternalBindingLocalQueue$inboundSchema),
+]);
+/** @internal */
+export type ExternalBindingUnion2$Outbound =
+  | ExternalBindingSqs$Outbound
+  | ExternalBindingPubsub$Outbound
+  | ExternalBindingServicebus$Outbound
+  | ExternalBindingLocalQueue$Outbound;
+
+/** @internal */
+export const ExternalBindingUnion2$outboundSchema: z.ZodType<
+  ExternalBindingUnion2$Outbound,
+  ExternalBindingUnion2
+> = z.union([
+  z.lazy(() => ExternalBindingSqs$outboundSchema),
+  z.lazy(() => ExternalBindingPubsub$outboundSchema),
+  z.lazy(() => ExternalBindingServicebus$outboundSchema),
+  z.lazy(() => ExternalBindingLocalQueue$outboundSchema),
+]);
+
+export function externalBindingUnion2ToJSON(
+  externalBindingUnion2: ExternalBindingUnion2,
+): string {
+  return JSON.stringify(
+    ExternalBindingUnion2$outboundSchema.parse(externalBindingUnion2),
+  );
+}
+export function externalBindingUnion2FromJSON(
+  jsonString: string,
+): SafeParseResult<ExternalBindingUnion2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ExternalBindingUnion2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExternalBindingUnion2' from JSON`,
+  );
+}
+
+/** @internal */
+export const StoragePathSecretRef$inboundSchema: z.ZodType<
+  StoragePathSecretRef,
+  unknown
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+/** @internal */
+export type StoragePathSecretRef$Outbound = {
+  key: string;
+  name: string;
+};
+
+/** @internal */
+export const StoragePathSecretRef$outboundSchema: z.ZodType<
+  StoragePathSecretRef$Outbound,
+  StoragePathSecretRef
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+
+export function storagePathSecretRefToJSON(
+  storagePathSecretRef: StoragePathSecretRef,
+): string {
+  return JSON.stringify(
+    StoragePathSecretRef$outboundSchema.parse(storagePathSecretRef),
+  );
+}
+export function storagePathSecretRefFromJSON(
+  jsonString: string,
+): SafeParseResult<StoragePathSecretRef, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StoragePathSecretRef$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StoragePathSecretRef' from JSON`,
+  );
+}
+
+/** @internal */
+export const StoragePath$inboundSchema: z.ZodType<StoragePath, unknown> = z
+  .object({
+    secretRef: z.lazy(() => StoragePathSecretRef$inboundSchema),
+  });
+/** @internal */
+export type StoragePath$Outbound = {
+  secretRef: StoragePathSecretRef$Outbound;
+};
+
+/** @internal */
+export const StoragePath$outboundSchema: z.ZodType<
+  StoragePath$Outbound,
+  StoragePath
+> = z.object({
+  secretRef: z.lazy(() => StoragePathSecretRef$outboundSchema),
+});
+
+export function storagePathToJSON(storagePath: StoragePath): string {
+  return JSON.stringify(StoragePath$outboundSchema.parse(storagePath));
+}
+export function storagePathFromJSON(
+  jsonString: string,
+): SafeParseResult<StoragePath, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StoragePath$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StoragePath' from JSON`,
+  );
+}
+
+/** @internal */
+export const TypeStorage4$inboundSchema: z.ZodEnum<typeof TypeStorage4> = z
+  .enum(TypeStorage4);
+/** @internal */
+export const TypeStorage4$outboundSchema: z.ZodEnum<typeof TypeStorage4> =
+  TypeStorage4$inboundSchema;
+
+/** @internal */
+export const ExternalBindingLocalStorage$inboundSchema: z.ZodType<
+  ExternalBindingLocalStorage,
+  unknown
+> = z.object({
+  storagePath: z.nullable(z.any()),
+  service: z.literal("local-storage"),
+  type: TypeStorage4$inboundSchema,
+});
+/** @internal */
+export type ExternalBindingLocalStorage$Outbound = {
+  storagePath: any | null;
+  service: "local-storage";
+  type: string;
+};
+
+/** @internal */
+export const ExternalBindingLocalStorage$outboundSchema: z.ZodType<
+  ExternalBindingLocalStorage$Outbound,
+  ExternalBindingLocalStorage
+> = z.object({
+  storagePath: z.nullable(z.any()),
+  service: z.literal("local-storage"),
+  type: TypeStorage4$outboundSchema,
+});
+
+export function externalBindingLocalStorageToJSON(
+  externalBindingLocalStorage: ExternalBindingLocalStorage,
+): string {
+  return JSON.stringify(
+    ExternalBindingLocalStorage$outboundSchema.parse(
+      externalBindingLocalStorage,
+    ),
+  );
+}
+export function externalBindingLocalStorageFromJSON(
+  jsonString: string,
+): SafeParseResult<ExternalBindingLocalStorage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ExternalBindingLocalStorage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExternalBindingLocalStorage' from JSON`,
+  );
+}
+
+/** @internal */
+export const BucketNameSecretRef2$inboundSchema: z.ZodType<
+  BucketNameSecretRef2,
+  unknown
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+/** @internal */
+export type BucketNameSecretRef2$Outbound = {
+  key: string;
+  name: string;
+};
+
+/** @internal */
+export const BucketNameSecretRef2$outboundSchema: z.ZodType<
+  BucketNameSecretRef2$Outbound,
+  BucketNameSecretRef2
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+
+export function bucketNameSecretRef2ToJSON(
+  bucketNameSecretRef2: BucketNameSecretRef2,
+): string {
+  return JSON.stringify(
+    BucketNameSecretRef2$outboundSchema.parse(bucketNameSecretRef2),
+  );
+}
+export function bucketNameSecretRef2FromJSON(
+  jsonString: string,
+): SafeParseResult<BucketNameSecretRef2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BucketNameSecretRef2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BucketNameSecretRef2' from JSON`,
+  );
+}
+
+/** @internal */
+export const BucketName2$inboundSchema: z.ZodType<BucketName2, unknown> = z
+  .object({
+    secretRef: z.lazy(() => BucketNameSecretRef2$inboundSchema),
+  });
+/** @internal */
+export type BucketName2$Outbound = {
+  secretRef: BucketNameSecretRef2$Outbound;
+};
+
+/** @internal */
+export const BucketName2$outboundSchema: z.ZodType<
+  BucketName2$Outbound,
+  BucketName2
+> = z.object({
+  secretRef: z.lazy(() => BucketNameSecretRef2$outboundSchema),
+});
+
+export function bucketName2ToJSON(bucketName2: BucketName2): string {
+  return JSON.stringify(BucketName2$outboundSchema.parse(bucketName2));
+}
+export function bucketName2FromJSON(
+  jsonString: string,
+): SafeParseResult<BucketName2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BucketName2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BucketName2' from JSON`,
+  );
+}
+
+/** @internal */
+export const TypeStorage3$inboundSchema: z.ZodEnum<typeof TypeStorage3> = z
+  .enum(TypeStorage3);
+/** @internal */
+export const TypeStorage3$outboundSchema: z.ZodEnum<typeof TypeStorage3> =
+  TypeStorage3$inboundSchema;
+
+/** @internal */
+export const ExternalBindingGcs$inboundSchema: z.ZodType<
+  ExternalBindingGcs,
+  unknown
+> = z.object({
+  bucketName: z.nullable(z.any()),
+  service: z.literal("gcs"),
+  type: TypeStorage3$inboundSchema,
+});
+/** @internal */
+export type ExternalBindingGcs$Outbound = {
+  bucketName: any | null;
+  service: "gcs";
+  type: string;
+};
+
+/** @internal */
+export const ExternalBindingGcs$outboundSchema: z.ZodType<
+  ExternalBindingGcs$Outbound,
+  ExternalBindingGcs
+> = z.object({
+  bucketName: z.nullable(z.any()),
+  service: z.literal("gcs"),
+  type: TypeStorage3$outboundSchema,
+});
+
+export function externalBindingGcsToJSON(
+  externalBindingGcs: ExternalBindingGcs,
+): string {
+  return JSON.stringify(
+    ExternalBindingGcs$outboundSchema.parse(externalBindingGcs),
+  );
+}
+export function externalBindingGcsFromJSON(
+  jsonString: string,
+): SafeParseResult<ExternalBindingGcs, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ExternalBindingGcs$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExternalBindingGcs' from JSON`,
+  );
+}
+
+/** @internal */
+export const AccountNameSecretRef1$inboundSchema: z.ZodType<
+  AccountNameSecretRef1,
+  unknown
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+/** @internal */
+export type AccountNameSecretRef1$Outbound = {
+  key: string;
+  name: string;
+};
+
+/** @internal */
+export const AccountNameSecretRef1$outboundSchema: z.ZodType<
+  AccountNameSecretRef1$Outbound,
+  AccountNameSecretRef1
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+
+export function accountNameSecretRef1ToJSON(
+  accountNameSecretRef1: AccountNameSecretRef1,
+): string {
+  return JSON.stringify(
+    AccountNameSecretRef1$outboundSchema.parse(accountNameSecretRef1),
+  );
+}
+export function accountNameSecretRef1FromJSON(
+  jsonString: string,
+): SafeParseResult<AccountNameSecretRef1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AccountNameSecretRef1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AccountNameSecretRef1' from JSON`,
+  );
+}
+
+/** @internal */
+export const AccountName1$inboundSchema: z.ZodType<AccountName1, unknown> = z
+  .object({
+    secretRef: z.lazy(() => AccountNameSecretRef1$inboundSchema),
+  });
+/** @internal */
+export type AccountName1$Outbound = {
+  secretRef: AccountNameSecretRef1$Outbound;
+};
+
+/** @internal */
+export const AccountName1$outboundSchema: z.ZodType<
+  AccountName1$Outbound,
+  AccountName1
+> = z.object({
+  secretRef: z.lazy(() => AccountNameSecretRef1$outboundSchema),
+});
+
+export function accountName1ToJSON(accountName1: AccountName1): string {
+  return JSON.stringify(AccountName1$outboundSchema.parse(accountName1));
+}
+export function accountName1FromJSON(
+  jsonString: string,
+): SafeParseResult<AccountName1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AccountName1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AccountName1' from JSON`,
+  );
+}
+
+/** @internal */
+export const ContainerNameSecretRef$inboundSchema: z.ZodType<
+  ContainerNameSecretRef,
+  unknown
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+/** @internal */
+export type ContainerNameSecretRef$Outbound = {
+  key: string;
+  name: string;
+};
+
+/** @internal */
+export const ContainerNameSecretRef$outboundSchema: z.ZodType<
+  ContainerNameSecretRef$Outbound,
+  ContainerNameSecretRef
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+
+export function containerNameSecretRefToJSON(
+  containerNameSecretRef: ContainerNameSecretRef,
+): string {
+  return JSON.stringify(
+    ContainerNameSecretRef$outboundSchema.parse(containerNameSecretRef),
+  );
+}
+export function containerNameSecretRefFromJSON(
+  jsonString: string,
+): SafeParseResult<ContainerNameSecretRef, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContainerNameSecretRef$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContainerNameSecretRef' from JSON`,
+  );
+}
+
+/** @internal */
+export const ContainerName$inboundSchema: z.ZodType<ContainerName, unknown> = z
+  .object({
+    secretRef: z.lazy(() => ContainerNameSecretRef$inboundSchema),
+  });
+/** @internal */
+export type ContainerName$Outbound = {
+  secretRef: ContainerNameSecretRef$Outbound;
+};
+
+/** @internal */
+export const ContainerName$outboundSchema: z.ZodType<
+  ContainerName$Outbound,
+  ContainerName
+> = z.object({
+  secretRef: z.lazy(() => ContainerNameSecretRef$outboundSchema),
+});
+
+export function containerNameToJSON(containerName: ContainerName): string {
+  return JSON.stringify(ContainerName$outboundSchema.parse(containerName));
+}
+export function containerNameFromJSON(
+  jsonString: string,
+): SafeParseResult<ContainerName, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContainerName$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContainerName' from JSON`,
+  );
+}
+
+/** @internal */
+export const TypeStorage2$inboundSchema: z.ZodEnum<typeof TypeStorage2> = z
+  .enum(TypeStorage2);
+/** @internal */
+export const TypeStorage2$outboundSchema: z.ZodEnum<typeof TypeStorage2> =
+  TypeStorage2$inboundSchema;
+
+/** @internal */
+export const ExternalBindingBlob$inboundSchema: z.ZodType<
+  ExternalBindingBlob,
+  unknown
+> = z.object({
+  accountName: z.nullable(z.any()),
+  containerName: z.nullable(z.any()),
+  service: z.literal("blob"),
+  type: TypeStorage2$inboundSchema,
+});
+/** @internal */
+export type ExternalBindingBlob$Outbound = {
+  accountName: any | null;
+  containerName: any | null;
+  service: "blob";
+  type: string;
+};
+
+/** @internal */
+export const ExternalBindingBlob$outboundSchema: z.ZodType<
+  ExternalBindingBlob$Outbound,
+  ExternalBindingBlob
+> = z.object({
+  accountName: z.nullable(z.any()),
+  containerName: z.nullable(z.any()),
+  service: z.literal("blob"),
+  type: TypeStorage2$outboundSchema,
+});
+
+export function externalBindingBlobToJSON(
+  externalBindingBlob: ExternalBindingBlob,
+): string {
+  return JSON.stringify(
+    ExternalBindingBlob$outboundSchema.parse(externalBindingBlob),
+  );
+}
+export function externalBindingBlobFromJSON(
+  jsonString: string,
+): SafeParseResult<ExternalBindingBlob, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ExternalBindingBlob$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExternalBindingBlob' from JSON`,
+  );
+}
+
+/** @internal */
+export const AccessKeyIdSecretRef$inboundSchema: z.ZodType<
+  AccessKeyIdSecretRef,
+  unknown
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+/** @internal */
+export type AccessKeyIdSecretRef$Outbound = {
+  key: string;
+  name: string;
+};
+
+/** @internal */
+export const AccessKeyIdSecretRef$outboundSchema: z.ZodType<
+  AccessKeyIdSecretRef$Outbound,
+  AccessKeyIdSecretRef
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+
+export function accessKeyIdSecretRefToJSON(
+  accessKeyIdSecretRef: AccessKeyIdSecretRef,
+): string {
+  return JSON.stringify(
+    AccessKeyIdSecretRef$outboundSchema.parse(accessKeyIdSecretRef),
+  );
+}
+export function accessKeyIdSecretRefFromJSON(
+  jsonString: string,
+): SafeParseResult<AccessKeyIdSecretRef, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AccessKeyIdSecretRef$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AccessKeyIdSecretRef' from JSON`,
+  );
+}
+
+/** @internal */
+export const AccessKeyId$inboundSchema: z.ZodType<AccessKeyId, unknown> = z
+  .object({
+    secretRef: z.lazy(() => AccessKeyIdSecretRef$inboundSchema),
+  });
+/** @internal */
+export type AccessKeyId$Outbound = {
+  secretRef: AccessKeyIdSecretRef$Outbound;
+};
+
+/** @internal */
+export const AccessKeyId$outboundSchema: z.ZodType<
+  AccessKeyId$Outbound,
+  AccessKeyId
+> = z.object({
+  secretRef: z.lazy(() => AccessKeyIdSecretRef$outboundSchema),
+});
+
+export function accessKeyIdToJSON(accessKeyId: AccessKeyId): string {
+  return JSON.stringify(AccessKeyId$outboundSchema.parse(accessKeyId));
+}
+export function accessKeyIdFromJSON(
+  jsonString: string,
+): SafeParseResult<AccessKeyId, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AccessKeyId$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AccessKeyId' from JSON`,
+  );
+}
+
+/** @internal */
+export const BucketNameSecretRef1$inboundSchema: z.ZodType<
+  BucketNameSecretRef1,
+  unknown
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+/** @internal */
+export type BucketNameSecretRef1$Outbound = {
+  key: string;
+  name: string;
+};
+
+/** @internal */
+export const BucketNameSecretRef1$outboundSchema: z.ZodType<
+  BucketNameSecretRef1$Outbound,
+  BucketNameSecretRef1
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+
+export function bucketNameSecretRef1ToJSON(
+  bucketNameSecretRef1: BucketNameSecretRef1,
+): string {
+  return JSON.stringify(
+    BucketNameSecretRef1$outboundSchema.parse(bucketNameSecretRef1),
+  );
+}
+export function bucketNameSecretRef1FromJSON(
+  jsonString: string,
+): SafeParseResult<BucketNameSecretRef1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BucketNameSecretRef1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BucketNameSecretRef1' from JSON`,
+  );
+}
+
+/** @internal */
+export const BucketName1$inboundSchema: z.ZodType<BucketName1, unknown> = z
+  .object({
+    secretRef: z.lazy(() => BucketNameSecretRef1$inboundSchema),
+  });
+/** @internal */
+export type BucketName1$Outbound = {
+  secretRef: BucketNameSecretRef1$Outbound;
+};
+
+/** @internal */
+export const BucketName1$outboundSchema: z.ZodType<
+  BucketName1$Outbound,
+  BucketName1
+> = z.object({
+  secretRef: z.lazy(() => BucketNameSecretRef1$outboundSchema),
+});
+
+export function bucketName1ToJSON(bucketName1: BucketName1): string {
+  return JSON.stringify(BucketName1$outboundSchema.parse(bucketName1));
+}
+export function bucketName1FromJSON(
+  jsonString: string,
+): SafeParseResult<BucketName1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BucketName1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BucketName1' from JSON`,
+  );
+}
+
+/** @internal */
+export const EndpointSecretRef$inboundSchema: z.ZodType<
+  EndpointSecretRef,
+  unknown
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+/** @internal */
+export type EndpointSecretRef$Outbound = {
+  key: string;
+  name: string;
+};
+
+/** @internal */
+export const EndpointSecretRef$outboundSchema: z.ZodType<
+  EndpointSecretRef$Outbound,
+  EndpointSecretRef
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+
+export function endpointSecretRefToJSON(
+  endpointSecretRef: EndpointSecretRef,
+): string {
+  return JSON.stringify(
+    EndpointSecretRef$outboundSchema.parse(endpointSecretRef),
+  );
+}
+export function endpointSecretRefFromJSON(
+  jsonString: string,
+): SafeParseResult<EndpointSecretRef, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EndpointSecretRef$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EndpointSecretRef' from JSON`,
+  );
+}
+
+/** @internal */
+export const ExternalBindingEndpoint$inboundSchema: z.ZodType<
+  ExternalBindingEndpoint,
+  unknown
+> = z.object({
+  secretRef: z.lazy(() => EndpointSecretRef$inboundSchema),
+});
+/** @internal */
+export type ExternalBindingEndpoint$Outbound = {
+  secretRef: EndpointSecretRef$Outbound;
+};
+
+/** @internal */
+export const ExternalBindingEndpoint$outboundSchema: z.ZodType<
+  ExternalBindingEndpoint$Outbound,
+  ExternalBindingEndpoint
+> = z.object({
+  secretRef: z.lazy(() => EndpointSecretRef$outboundSchema),
+});
+
+export function externalBindingEndpointToJSON(
+  externalBindingEndpoint: ExternalBindingEndpoint,
+): string {
+  return JSON.stringify(
+    ExternalBindingEndpoint$outboundSchema.parse(externalBindingEndpoint),
+  );
+}
+export function externalBindingEndpointFromJSON(
+  jsonString: string,
+): SafeParseResult<ExternalBindingEndpoint, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ExternalBindingEndpoint$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExternalBindingEndpoint' from JSON`,
+  );
+}
+
+/** @internal */
+export const RegionSecretRef1$inboundSchema: z.ZodType<
+  RegionSecretRef1,
+  unknown
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+/** @internal */
+export type RegionSecretRef1$Outbound = {
+  key: string;
+  name: string;
+};
+
+/** @internal */
+export const RegionSecretRef1$outboundSchema: z.ZodType<
+  RegionSecretRef1$Outbound,
+  RegionSecretRef1
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+
+export function regionSecretRef1ToJSON(
+  regionSecretRef1: RegionSecretRef1,
+): string {
+  return JSON.stringify(
+    RegionSecretRef1$outboundSchema.parse(regionSecretRef1),
+  );
+}
+export function regionSecretRef1FromJSON(
+  jsonString: string,
+): SafeParseResult<RegionSecretRef1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RegionSecretRef1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RegionSecretRef1' from JSON`,
+  );
+}
+
+/** @internal */
+export const Region1$inboundSchema: z.ZodType<Region1, unknown> = z.object({
+  secretRef: z.lazy(() => RegionSecretRef1$inboundSchema),
+});
+/** @internal */
+export type Region1$Outbound = {
+  secretRef: RegionSecretRef1$Outbound;
+};
+
+/** @internal */
+export const Region1$outboundSchema: z.ZodType<Region1$Outbound, Region1> = z
+  .object({
+    secretRef: z.lazy(() => RegionSecretRef1$outboundSchema),
+  });
+
+export function region1ToJSON(region1: Region1): string {
+  return JSON.stringify(Region1$outboundSchema.parse(region1));
+}
+export function region1FromJSON(
+  jsonString: string,
+): SafeParseResult<Region1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Region1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Region1' from JSON`,
+  );
+}
+
+/** @internal */
+export const SecretAccessKeySecretRef$inboundSchema: z.ZodType<
+  SecretAccessKeySecretRef,
+  unknown
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+/** @internal */
+export type SecretAccessKeySecretRef$Outbound = {
+  key: string;
+  name: string;
+};
+
+/** @internal */
+export const SecretAccessKeySecretRef$outboundSchema: z.ZodType<
+  SecretAccessKeySecretRef$Outbound,
+  SecretAccessKeySecretRef
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+});
+
+export function secretAccessKeySecretRefToJSON(
+  secretAccessKeySecretRef: SecretAccessKeySecretRef,
+): string {
+  return JSON.stringify(
+    SecretAccessKeySecretRef$outboundSchema.parse(secretAccessKeySecretRef),
+  );
+}
+export function secretAccessKeySecretRefFromJSON(
+  jsonString: string,
+): SafeParseResult<SecretAccessKeySecretRef, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SecretAccessKeySecretRef$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SecretAccessKeySecretRef' from JSON`,
+  );
+}
+
+/** @internal */
+export const SecretAccessKey$inboundSchema: z.ZodType<
+  SecretAccessKey,
+  unknown
+> = z.object({
+  secretRef: z.lazy(() => SecretAccessKeySecretRef$inboundSchema),
+});
+/** @internal */
+export type SecretAccessKey$Outbound = {
+  secretRef: SecretAccessKeySecretRef$Outbound;
+};
+
+/** @internal */
+export const SecretAccessKey$outboundSchema: z.ZodType<
+  SecretAccessKey$Outbound,
+  SecretAccessKey
+> = z.object({
+  secretRef: z.lazy(() => SecretAccessKeySecretRef$outboundSchema),
+});
+
+export function secretAccessKeyToJSON(
+  secretAccessKey: SecretAccessKey,
+): string {
+  return JSON.stringify(SecretAccessKey$outboundSchema.parse(secretAccessKey));
+}
+export function secretAccessKeyFromJSON(
+  jsonString: string,
+): SafeParseResult<SecretAccessKey, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SecretAccessKey$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SecretAccessKey' from JSON`,
+  );
+}
+
+/** @internal */
+export const TypeStorage1$inboundSchema: z.ZodEnum<typeof TypeStorage1> = z
+  .enum(TypeStorage1);
+/** @internal */
+export const TypeStorage1$outboundSchema: z.ZodEnum<typeof TypeStorage1> =
+  TypeStorage1$inboundSchema;
+
+/** @internal */
+export const ExternalBindingS3$inboundSchema: z.ZodType<
+  ExternalBindingS3,
+  unknown
+> = z.object({
+  accessKeyId: z.nullable(z.any()).optional(),
+  bucketName: z.nullable(z.any()),
+  endpoint: z.nullable(z.any()).optional(),
+  forcePathStyle: z.nullable(z.boolean()).optional(),
+  region: z.nullable(z.any()).optional(),
+  secretAccessKey: z.nullable(z.any()).optional(),
+  service: z.literal("s3"),
+  type: TypeStorage1$inboundSchema,
+});
+/** @internal */
+export type ExternalBindingS3$Outbound = {
+  accessKeyId?: any | null | undefined;
+  bucketName: any | null;
+  endpoint?: any | null | undefined;
+  forcePathStyle?: boolean | null | undefined;
+  region?: any | null | undefined;
+  secretAccessKey?: any | null | undefined;
+  service: "s3";
+  type: string;
+};
+
+/** @internal */
+export const ExternalBindingS3$outboundSchema: z.ZodType<
+  ExternalBindingS3$Outbound,
+  ExternalBindingS3
+> = z.object({
+  accessKeyId: z.nullable(z.any()).optional(),
+  bucketName: z.nullable(z.any()),
+  endpoint: z.nullable(z.any()).optional(),
+  forcePathStyle: z.nullable(z.boolean()).optional(),
+  region: z.nullable(z.any()).optional(),
+  secretAccessKey: z.nullable(z.any()).optional(),
+  service: z.literal("s3"),
+  type: TypeStorage1$outboundSchema,
+});
+
+export function externalBindingS3ToJSON(
+  externalBindingS3: ExternalBindingS3,
+): string {
+  return JSON.stringify(
+    ExternalBindingS3$outboundSchema.parse(externalBindingS3),
+  );
+}
+export function externalBindingS3FromJSON(
+  jsonString: string,
+): SafeParseResult<ExternalBindingS3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ExternalBindingS3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExternalBindingS3' from JSON`,
+  );
+}
+
+/** @internal */
+export const ExternalBindingUnion1$inboundSchema: z.ZodType<
+  ExternalBindingUnion1,
+  unknown
+> = z.union([
+  z.lazy(() => ExternalBindingS3$inboundSchema),
+  z.lazy(() => ExternalBindingBlob$inboundSchema),
+  z.lazy(() => ExternalBindingGcs$inboundSchema),
+  z.lazy(() => ExternalBindingLocalStorage$inboundSchema),
+]);
+/** @internal */
+export type ExternalBindingUnion1$Outbound =
+  | ExternalBindingS3$Outbound
+  | ExternalBindingBlob$Outbound
+  | ExternalBindingGcs$Outbound
+  | ExternalBindingLocalStorage$Outbound;
+
+/** @internal */
+export const ExternalBindingUnion1$outboundSchema: z.ZodType<
+  ExternalBindingUnion1$Outbound,
+  ExternalBindingUnion1
+> = z.union([
+  z.lazy(() => ExternalBindingS3$outboundSchema),
+  z.lazy(() => ExternalBindingBlob$outboundSchema),
+  z.lazy(() => ExternalBindingGcs$outboundSchema),
+  z.lazy(() => ExternalBindingLocalStorage$outboundSchema),
+]);
+
+export function externalBindingUnion1ToJSON(
+  externalBindingUnion1: ExternalBindingUnion1,
+): string {
+  return JSON.stringify(
+    ExternalBindingUnion1$outboundSchema.parse(externalBindingUnion1),
+  );
+}
+export function externalBindingUnion1FromJSON(
+  jsonString: string,
+): SafeParseResult<ExternalBindingUnion1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ExternalBindingUnion1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExternalBindingUnion1' from JSON`,
+  );
+}
+
+/** @internal */
+export const ExternalBindingUnion$inboundSchema: z.ZodType<
+  ExternalBindingUnion,
+  unknown
+> = z.union([
+  ExternalBindingContainerAppsEnvironment$inboundSchema,
+  ExternalBindingAi$inboundSchema,
+  z.union([
+    z.lazy(() => ExternalBindingS3$inboundSchema),
+    z.lazy(() => ExternalBindingBlob$inboundSchema),
+    z.lazy(() => ExternalBindingGcs$inboundSchema),
+    z.lazy(() => ExternalBindingLocalStorage$inboundSchema),
+  ]),
+  z.union([
+    z.lazy(() => ExternalBindingSqs$inboundSchema),
+    z.lazy(() => ExternalBindingPubsub$inboundSchema),
+    z.lazy(() => ExternalBindingServicebus$inboundSchema),
+    z.lazy(() => ExternalBindingLocalQueue$inboundSchema),
+  ]),
+  z.union([
+    z.lazy(() => ExternalBindingDynamodb$inboundSchema),
+    z.lazy(() => ExternalBindingFirestore$inboundSchema),
+    z.lazy(() => ExternalBindingTablestorage$inboundSchema),
+    z.lazy(() => ExternalBindingRedis$inboundSchema),
+    ExternalBindingLocalKv$inboundSchema,
+  ]),
+  ExternalBindingUnion4$inboundSchema,
+  ExternalBindingUnion5$inboundSchema,
+  ExternalBindingUnion6$inboundSchema,
+]);
+/** @internal */
+export type ExternalBindingUnion$Outbound =
+  | ExternalBindingContainerAppsEnvironment$Outbound
+  | ExternalBindingAi$Outbound
+  | ExternalBindingS3$Outbound
+  | ExternalBindingBlob$Outbound
+  | ExternalBindingGcs$Outbound
+  | ExternalBindingLocalStorage$Outbound
+  | ExternalBindingSqs$Outbound
+  | ExternalBindingPubsub$Outbound
+  | ExternalBindingServicebus$Outbound
+  | ExternalBindingLocalQueue$Outbound
+  | ExternalBindingDynamodb$Outbound
+  | ExternalBindingFirestore$Outbound
+  | ExternalBindingTablestorage$Outbound
+  | ExternalBindingRedis$Outbound
+  | ExternalBindingLocalKv$Outbound
+  | ExternalBindingUnion4$Outbound
+  | ExternalBindingUnion5$Outbound
+  | ExternalBindingUnion6$Outbound;
+
+/** @internal */
+export const ExternalBindingUnion$outboundSchema: z.ZodType<
+  ExternalBindingUnion$Outbound,
+  ExternalBindingUnion
+> = z.union([
+  ExternalBindingContainerAppsEnvironment$outboundSchema,
+  ExternalBindingAi$outboundSchema,
+  z.union([
+    z.lazy(() => ExternalBindingS3$outboundSchema),
+    z.lazy(() => ExternalBindingBlob$outboundSchema),
+    z.lazy(() => ExternalBindingGcs$outboundSchema),
+    z.lazy(() => ExternalBindingLocalStorage$outboundSchema),
+  ]),
+  z.union([
+    z.lazy(() => ExternalBindingSqs$outboundSchema),
+    z.lazy(() => ExternalBindingPubsub$outboundSchema),
+    z.lazy(() => ExternalBindingServicebus$outboundSchema),
+    z.lazy(() => ExternalBindingLocalQueue$outboundSchema),
+  ]),
+  z.union([
+    z.lazy(() => ExternalBindingDynamodb$outboundSchema),
+    z.lazy(() => ExternalBindingFirestore$outboundSchema),
+    z.lazy(() => ExternalBindingTablestorage$outboundSchema),
+    z.lazy(() => ExternalBindingRedis$outboundSchema),
+    ExternalBindingLocalKv$outboundSchema,
+  ]),
+  ExternalBindingUnion4$outboundSchema,
+  ExternalBindingUnion5$outboundSchema,
+  ExternalBindingUnion6$outboundSchema,
+]);
+
+export function externalBindingUnionToJSON(
+  externalBindingUnion: ExternalBindingUnion,
+): string {
+  return JSON.stringify(
+    ExternalBindingUnion$outboundSchema.parse(externalBindingUnion),
+  );
+}
+export function externalBindingUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<ExternalBindingUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ExternalBindingUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExternalBindingUnion' from JSON`,
+  );
+}