All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.pulumi.gcp.appengine.kotlin.StandardAppVersionArgs.kt Maven / Gradle / Ivy

Go to download

Build cloud applications and infrastructure by combining the safety and reliability of infrastructure as code with the power of the Kotlin programming language.

There is a newer version: 8.10.0.0
Show newest version
@file:Suppress("NAME_SHADOWING", "DEPRECATION")

package com.pulumi.gcp.appengine.kotlin

import com.pulumi.core.Output
import com.pulumi.core.Output.of
import com.pulumi.gcp.appengine.StandardAppVersionArgs.builder
import com.pulumi.gcp.appengine.kotlin.inputs.StandardAppVersionAutomaticScalingArgs
import com.pulumi.gcp.appengine.kotlin.inputs.StandardAppVersionAutomaticScalingArgsBuilder
import com.pulumi.gcp.appengine.kotlin.inputs.StandardAppVersionBasicScalingArgs
import com.pulumi.gcp.appengine.kotlin.inputs.StandardAppVersionBasicScalingArgsBuilder
import com.pulumi.gcp.appengine.kotlin.inputs.StandardAppVersionDeploymentArgs
import com.pulumi.gcp.appengine.kotlin.inputs.StandardAppVersionDeploymentArgsBuilder
import com.pulumi.gcp.appengine.kotlin.inputs.StandardAppVersionEntrypointArgs
import com.pulumi.gcp.appengine.kotlin.inputs.StandardAppVersionEntrypointArgsBuilder
import com.pulumi.gcp.appengine.kotlin.inputs.StandardAppVersionHandlerArgs
import com.pulumi.gcp.appengine.kotlin.inputs.StandardAppVersionHandlerArgsBuilder
import com.pulumi.gcp.appengine.kotlin.inputs.StandardAppVersionLibraryArgs
import com.pulumi.gcp.appengine.kotlin.inputs.StandardAppVersionLibraryArgsBuilder
import com.pulumi.gcp.appengine.kotlin.inputs.StandardAppVersionManualScalingArgs
import com.pulumi.gcp.appengine.kotlin.inputs.StandardAppVersionManualScalingArgsBuilder
import com.pulumi.gcp.appengine.kotlin.inputs.StandardAppVersionVpcAccessConnectorArgs
import com.pulumi.gcp.appengine.kotlin.inputs.StandardAppVersionVpcAccessConnectorArgsBuilder
import com.pulumi.kotlin.ConvertibleToJava
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.applySuspend
import kotlin.Boolean
import kotlin.Pair
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.collections.Map
import kotlin.jvm.JvmName

/**
 * Standard App Version resource to create a new version of standard GAE Application.
 * Learn about the differences between the standard environment and the flexible environment
 * at https://cloud.google.com/appengine/docs/the-appengine-environments.
 * Currently supporting Zip and File Containers.
 * To get more information about StandardAppVersion, see:
 * * [API documentation](https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1/apps.services.versions)
 * * How-to Guides
 *     * [Official Documentation](https://cloud.google.com/appengine/docs/standard)
 * ## Example Usage
 * ### App Engine Standard App Version
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const customServiceAccount = new gcp.serviceaccount.Account("custom_service_account", {
 *     accountId: "my-account",
 *     displayName: "Custom Service Account",
 * });
 * const gaeApi = new gcp.projects.IAMMember("gae_api", {
 *     project: customServiceAccount.project,
 *     role: "roles/compute.networkUser",
 *     member: pulumi.interpolate`serviceAccount:${customServiceAccount.email}`,
 * });
 * const storageViewer = new gcp.projects.IAMMember("storage_viewer", {
 *     project: customServiceAccount.project,
 *     role: "roles/storage.objectViewer",
 *     member: pulumi.interpolate`serviceAccount:${customServiceAccount.email}`,
 * });
 * const bucket = new gcp.storage.Bucket("bucket", {
 *     name: "appengine-static-content",
 *     location: "US",
 * });
 * const object = new gcp.storage.BucketObject("object", {
 *     name: "hello-world.zip",
 *     bucket: bucket.name,
 *     source: new pulumi.asset.FileAsset("./test-fixtures/hello-world.zip"),
 * });
 * const myappV1 = new gcp.appengine.StandardAppVersion("myapp_v1", {
 *     versionId: "v1",
 *     service: "myapp",
 *     runtime: "nodejs20",
 *     entrypoint: {
 *         shell: "node ./app.js",
 *     },
 *     deployment: {
 *         zip: {
 *             sourceUrl: pulumi.interpolate`https://storage.googleapis.com/${bucket.name}/${object.name}`,
 *         },
 *     },
 *     envVariables: {
 *         port: "8080",
 *     },
 *     automaticScaling: {
 *         maxConcurrentRequests: 10,
 *         minIdleInstances: 1,
 *         maxIdleInstances: 3,
 *         minPendingLatency: "1s",
 *         maxPendingLatency: "5s",
 *         standardSchedulerSettings: {
 *             targetCpuUtilization: 0.5,
 *             targetThroughputUtilization: 0.75,
 *             minInstances: 2,
 *             maxInstances: 10,
 *         },
 *     },
 *     deleteServiceOnDestroy: true,
 *     serviceAccount: customServiceAccount.email,
 * });
 * const myappV2 = new gcp.appengine.StandardAppVersion("myapp_v2", {
 *     versionId: "v2",
 *     service: "myapp",
 *     runtime: "nodejs20",
 *     appEngineApis: true,
 *     entrypoint: {
 *         shell: "node ./app.js",
 *     },
 *     deployment: {
 *         zip: {
 *             sourceUrl: pulumi.interpolate`https://storage.googleapis.com/${bucket.name}/${object.name}`,
 *         },
 *     },
 *     envVariables: {
 *         port: "8080",
 *     },
 *     basicScaling: {
 *         maxInstances: 5,
 *     },
 *     noopOnDestroy: true,
 *     serviceAccount: customServiceAccount.email,
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * custom_service_account = gcp.serviceaccount.Account("custom_service_account",
 *     account_id="my-account",
 *     display_name="Custom Service Account")
 * gae_api = gcp.projects.IAMMember("gae_api",
 *     project=custom_service_account.project,
 *     role="roles/compute.networkUser",
 *     member=custom_service_account.email.apply(lambda email: f"serviceAccount:{email}"))
 * storage_viewer = gcp.projects.IAMMember("storage_viewer",
 *     project=custom_service_account.project,
 *     role="roles/storage.objectViewer",
 *     member=custom_service_account.email.apply(lambda email: f"serviceAccount:{email}"))
 * bucket = gcp.storage.Bucket("bucket",
 *     name="appengine-static-content",
 *     location="US")
 * object = gcp.storage.BucketObject("object",
 *     name="hello-world.zip",
 *     bucket=bucket.name,
 *     source=pulumi.FileAsset("./test-fixtures/hello-world.zip"))
 * myapp_v1 = gcp.appengine.StandardAppVersion("myapp_v1",
 *     version_id="v1",
 *     service="myapp",
 *     runtime="nodejs20",
 *     entrypoint=gcp.appengine.StandardAppVersionEntrypointArgs(
 *         shell="node ./app.js",
 *     ),
 *     deployment=gcp.appengine.StandardAppVersionDeploymentArgs(
 *         zip=gcp.appengine.StandardAppVersionDeploymentZipArgs(
 *             source_url=pulumi.Output.all(bucket.name, object.name).apply(lambda bucketName, objectName: f"https://storage.googleapis.com/{bucket_name}/{object_name}"),
 *         ),
 *     ),
 *     env_variables={
 *         "port": "8080",
 *     },
 *     automatic_scaling=gcp.appengine.StandardAppVersionAutomaticScalingArgs(
 *         max_concurrent_requests=10,
 *         min_idle_instances=1,
 *         max_idle_instances=3,
 *         min_pending_latency="1s",
 *         max_pending_latency="5s",
 *         standard_scheduler_settings=gcp.appengine.StandardAppVersionAutomaticScalingStandardSchedulerSettingsArgs(
 *             target_cpu_utilization=0.5,
 *             target_throughput_utilization=0.75,
 *             min_instances=2,
 *             max_instances=10,
 *         ),
 *     ),
 *     delete_service_on_destroy=True,
 *     service_account=custom_service_account.email)
 * myapp_v2 = gcp.appengine.StandardAppVersion("myapp_v2",
 *     version_id="v2",
 *     service="myapp",
 *     runtime="nodejs20",
 *     app_engine_apis=True,
 *     entrypoint=gcp.appengine.StandardAppVersionEntrypointArgs(
 *         shell="node ./app.js",
 *     ),
 *     deployment=gcp.appengine.StandardAppVersionDeploymentArgs(
 *         zip=gcp.appengine.StandardAppVersionDeploymentZipArgs(
 *             source_url=pulumi.Output.all(bucket.name, object.name).apply(lambda bucketName, objectName: f"https://storage.googleapis.com/{bucket_name}/{object_name}"),
 *         ),
 *     ),
 *     env_variables={
 *         "port": "8080",
 *     },
 *     basic_scaling=gcp.appengine.StandardAppVersionBasicScalingArgs(
 *         max_instances=5,
 *     ),
 *     noop_on_destroy=True,
 *     service_account=custom_service_account.email)
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var customServiceAccount = new Gcp.ServiceAccount.Account("custom_service_account", new()
 *     {
 *         AccountId = "my-account",
 *         DisplayName = "Custom Service Account",
 *     });
 *     var gaeApi = new Gcp.Projects.IAMMember("gae_api", new()
 *     {
 *         Project = customServiceAccount.Project,
 *         Role = "roles/compute.networkUser",
 *         Member = customServiceAccount.Email.Apply(email => $"serviceAccount:{email}"),
 *     });
 *     var storageViewer = new Gcp.Projects.IAMMember("storage_viewer", new()
 *     {
 *         Project = customServiceAccount.Project,
 *         Role = "roles/storage.objectViewer",
 *         Member = customServiceAccount.Email.Apply(email => $"serviceAccount:{email}"),
 *     });
 *     var bucket = new Gcp.Storage.Bucket("bucket", new()
 *     {
 *         Name = "appengine-static-content",
 *         Location = "US",
 *     });
 *     var @object = new Gcp.Storage.BucketObject("object", new()
 *     {
 *         Name = "hello-world.zip",
 *         Bucket = bucket.Name,
 *         Source = new FileAsset("./test-fixtures/hello-world.zip"),
 *     });
 *     var myappV1 = new Gcp.AppEngine.StandardAppVersion("myapp_v1", new()
 *     {
 *         VersionId = "v1",
 *         Service = "myapp",
 *         Runtime = "nodejs20",
 *         Entrypoint = new Gcp.AppEngine.Inputs.StandardAppVersionEntrypointArgs
 *         {
 *             Shell = "node ./app.js",
 *         },
 *         Deployment = new Gcp.AppEngine.Inputs.StandardAppVersionDeploymentArgs
 *         {
 *             Zip = new Gcp.AppEngine.Inputs.StandardAppVersionDeploymentZipArgs
 *             {
 *                 SourceUrl = Output.Tuple(bucket.Name, @object.Name).Apply(values =>
 *                 {
 *                     var bucketName = values.Item1;
 *                     var objectName = values.Item2;
 *                     return $"https://storage.googleapis.com/{bucketName}/{objectName}";
 *                 }),
 *             },
 *         },
 *         EnvVariables =
 *         {
 *             { "port", "8080" },
 *         },
 *         AutomaticScaling = new Gcp.AppEngine.Inputs.StandardAppVersionAutomaticScalingArgs
 *         {
 *             MaxConcurrentRequests = 10,
 *             MinIdleInstances = 1,
 *             MaxIdleInstances = 3,
 *             MinPendingLatency = "1s",
 *             MaxPendingLatency = "5s",
 *             StandardSchedulerSettings = new Gcp.AppEngine.Inputs.StandardAppVersionAutomaticScalingStandardSchedulerSettingsArgs
 *             {
 *                 TargetCpuUtilization = 0.5,
 *                 TargetThroughputUtilization = 0.75,
 *                 MinInstances = 2,
 *                 MaxInstances = 10,
 *             },
 *         },
 *         DeleteServiceOnDestroy = true,
 *         ServiceAccount = customServiceAccount.Email,
 *     });
 *     var myappV2 = new Gcp.AppEngine.StandardAppVersion("myapp_v2", new()
 *     {
 *         VersionId = "v2",
 *         Service = "myapp",
 *         Runtime = "nodejs20",
 *         AppEngineApis = true,
 *         Entrypoint = new Gcp.AppEngine.Inputs.StandardAppVersionEntrypointArgs
 *         {
 *             Shell = "node ./app.js",
 *         },
 *         Deployment = new Gcp.AppEngine.Inputs.StandardAppVersionDeploymentArgs
 *         {
 *             Zip = new Gcp.AppEngine.Inputs.StandardAppVersionDeploymentZipArgs
 *             {
 *                 SourceUrl = Output.Tuple(bucket.Name, @object.Name).Apply(values =>
 *                 {
 *                     var bucketName = values.Item1;
 *                     var objectName = values.Item2;
 *                     return $"https://storage.googleapis.com/{bucketName}/{objectName}";
 *                 }),
 *             },
 *         },
 *         EnvVariables =
 *         {
 *             { "port", "8080" },
 *         },
 *         BasicScaling = new Gcp.AppEngine.Inputs.StandardAppVersionBasicScalingArgs
 *         {
 *             MaxInstances = 5,
 *         },
 *         NoopOnDestroy = true,
 *         ServiceAccount = customServiceAccount.Email,
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"fmt"
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/appengine"
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/projects"
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/serviceaccount"
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/storage"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		customServiceAccount, err := serviceaccount.NewAccount(ctx, "custom_service_account", &serviceaccount.AccountArgs{
 * 			AccountId:   pulumi.String("my-account"),
 * 			DisplayName: pulumi.String("Custom Service Account"),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = projects.NewIAMMember(ctx, "gae_api", &projects.IAMMemberArgs{
 * 			Project: customServiceAccount.Project,
 * 			Role:    pulumi.String("roles/compute.networkUser"),
 * 			Member: customServiceAccount.Email.ApplyT(func(email string) (string, error) {
 * 				return fmt.Sprintf("serviceAccount:%v", email), nil
 * 			}).(pulumi.StringOutput),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = projects.NewIAMMember(ctx, "storage_viewer", &projects.IAMMemberArgs{
 * 			Project: customServiceAccount.Project,
 * 			Role:    pulumi.String("roles/storage.objectViewer"),
 * 			Member: customServiceAccount.Email.ApplyT(func(email string) (string, error) {
 * 				return fmt.Sprintf("serviceAccount:%v", email), nil
 * 			}).(pulumi.StringOutput),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		bucket, err := storage.NewBucket(ctx, "bucket", &storage.BucketArgs{
 * 			Name:     pulumi.String("appengine-static-content"),
 * 			Location: pulumi.String("US"),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		object, err := storage.NewBucketObject(ctx, "object", &storage.BucketObjectArgs{
 * 			Name:   pulumi.String("hello-world.zip"),
 * 			Bucket: bucket.Name,
 * 			Source: pulumi.NewFileAsset("./test-fixtures/hello-world.zip"),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = appengine.NewStandardAppVersion(ctx, "myapp_v1", &appengine.StandardAppVersionArgs{
 * 			VersionId: pulumi.String("v1"),
 * 			Service:   pulumi.String("myapp"),
 * 			Runtime:   pulumi.String("nodejs20"),
 * 			Entrypoint: &appengine.StandardAppVersionEntrypointArgs{
 * 				Shell: pulumi.String("node ./app.js"),
 * 			},
 * 			Deployment: &appengine.StandardAppVersionDeploymentArgs{
 * 				Zip: &appengine.StandardAppVersionDeploymentZipArgs{
 * 					SourceUrl: pulumi.All(bucket.Name, object.Name).ApplyT(func(_args []interface{}) (string, error) {
 * 						bucketName := _args[0].(string)
 * 						objectName := _args[1].(string)
 * 						return fmt.Sprintf("https://storage.googleapis.com/%v/%v", bucketName, objectName), nil
 * 					}).(pulumi.StringOutput),
 * 				},
 * 			},
 * 			EnvVariables: pulumi.StringMap{
 * 				"port": pulumi.String("8080"),
 * 			},
 * 			AutomaticScaling: &appengine.StandardAppVersionAutomaticScalingArgs{
 * 				MaxConcurrentRequests: pulumi.Int(10),
 * 				MinIdleInstances:      pulumi.Int(1),
 * 				MaxIdleInstances:      pulumi.Int(3),
 * 				MinPendingLatency:     pulumi.String("1s"),
 * 				MaxPendingLatency:     pulumi.String("5s"),
 * 				StandardSchedulerSettings: &appengine.StandardAppVersionAutomaticScalingStandardSchedulerSettingsArgs{
 * 					TargetCpuUtilization:        pulumi.Float64(0.5),
 * 					TargetThroughputUtilization: pulumi.Float64(0.75),
 * 					MinInstances:                pulumi.Int(2),
 * 					MaxInstances:                pulumi.Int(10),
 * 				},
 * 			},
 * 			DeleteServiceOnDestroy: pulumi.Bool(true),
 * 			ServiceAccount:         customServiceAccount.Email,
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = appengine.NewStandardAppVersion(ctx, "myapp_v2", &appengine.StandardAppVersionArgs{
 * 			VersionId:     pulumi.String("v2"),
 * 			Service:       pulumi.String("myapp"),
 * 			Runtime:       pulumi.String("nodejs20"),
 * 			AppEngineApis: pulumi.Bool(true),
 * 			Entrypoint: &appengine.StandardAppVersionEntrypointArgs{
 * 				Shell: pulumi.String("node ./app.js"),
 * 			},
 * 			Deployment: &appengine.StandardAppVersionDeploymentArgs{
 * 				Zip: &appengine.StandardAppVersionDeploymentZipArgs{
 * 					SourceUrl: pulumi.All(bucket.Name, object.Name).ApplyT(func(_args []interface{}) (string, error) {
 * 						bucketName := _args[0].(string)
 * 						objectName := _args[1].(string)
 * 						return fmt.Sprintf("https://storage.googleapis.com/%v/%v", bucketName, objectName), nil
 * 					}).(pulumi.StringOutput),
 * 				},
 * 			},
 * 			EnvVariables: pulumi.StringMap{
 * 				"port": pulumi.String("8080"),
 * 			},
 * 			BasicScaling: &appengine.StandardAppVersionBasicScalingArgs{
 * 				MaxInstances: pulumi.Int(5),
 * 			},
 * 			NoopOnDestroy:  pulumi.Bool(true),
 * 			ServiceAccount: customServiceAccount.Email,
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		return nil
 * 	})
 * }
 * ```
 * ```java
 * package generated_program;
 * import com.pulumi.Context;
 * import com.pulumi.Pulumi;
 * import com.pulumi.core.Output;
 * import com.pulumi.gcp.serviceaccount.Account;
 * import com.pulumi.gcp.serviceaccount.AccountArgs;
 * import com.pulumi.gcp.projects.IAMMember;
 * import com.pulumi.gcp.projects.IAMMemberArgs;
 * import com.pulumi.gcp.storage.Bucket;
 * import com.pulumi.gcp.storage.BucketArgs;
 * import com.pulumi.gcp.storage.BucketObject;
 * import com.pulumi.gcp.storage.BucketObjectArgs;
 * import com.pulumi.gcp.appengine.StandardAppVersion;
 * import com.pulumi.gcp.appengine.StandardAppVersionArgs;
 * import com.pulumi.gcp.appengine.inputs.StandardAppVersionEntrypointArgs;
 * import com.pulumi.gcp.appengine.inputs.StandardAppVersionDeploymentArgs;
 * import com.pulumi.gcp.appengine.inputs.StandardAppVersionDeploymentZipArgs;
 * import com.pulumi.gcp.appengine.inputs.StandardAppVersionAutomaticScalingArgs;
 * import com.pulumi.gcp.appengine.inputs.StandardAppVersionAutomaticScalingStandardSchedulerSettingsArgs;
 * import com.pulumi.gcp.appengine.inputs.StandardAppVersionBasicScalingArgs;
 * import com.pulumi.asset.FileAsset;
 * import java.util.List;
 * import java.util.ArrayList;
 * import java.util.Map;
 * import java.io.File;
 * import java.nio.file.Files;
 * import java.nio.file.Paths;
 * public class App {
 *     public static void main(String[] args) {
 *         Pulumi.run(App::stack);
 *     }
 *     public static void stack(Context ctx) {
 *         var customServiceAccount = new Account("customServiceAccount", AccountArgs.builder()
 *             .accountId("my-account")
 *             .displayName("Custom Service Account")
 *             .build());
 *         var gaeApi = new IAMMember("gaeApi", IAMMemberArgs.builder()
 *             .project(customServiceAccount.project())
 *             .role("roles/compute.networkUser")
 *             .member(customServiceAccount.email().applyValue(email -> String.format("serviceAccount:%s", email)))
 *             .build());
 *         var storageViewer = new IAMMember("storageViewer", IAMMemberArgs.builder()
 *             .project(customServiceAccount.project())
 *             .role("roles/storage.objectViewer")
 *             .member(customServiceAccount.email().applyValue(email -> String.format("serviceAccount:%s", email)))
 *             .build());
 *         var bucket = new Bucket("bucket", BucketArgs.builder()
 *             .name("appengine-static-content")
 *             .location("US")
 *             .build());
 *         var object = new BucketObject("object", BucketObjectArgs.builder()
 *             .name("hello-world.zip")
 *             .bucket(bucket.name())
 *             .source(new FileAsset("./test-fixtures/hello-world.zip"))
 *             .build());
 *         var myappV1 = new StandardAppVersion("myappV1", StandardAppVersionArgs.builder()
 *             .versionId("v1")
 *             .service("myapp")
 *             .runtime("nodejs20")
 *             .entrypoint(StandardAppVersionEntrypointArgs.builder()
 *                 .shell("node ./app.js")
 *                 .build())
 *             .deployment(StandardAppVersionDeploymentArgs.builder()
 *                 .zip(StandardAppVersionDeploymentZipArgs.builder()
 *                     .sourceUrl(Output.tuple(bucket.name(), object.name()).applyValue(values -> {
 *                         var bucketName = values.t1;
 *                         var objectName = values.t2;
 *                         return String.format("https://storage.googleapis.com/%s/%s", bucketName,objectName);
 *                     }))
 *                     .build())
 *                 .build())
 *             .envVariables(Map.of("port", "8080"))
 *             .automaticScaling(StandardAppVersionAutomaticScalingArgs.builder()
 *                 .maxConcurrentRequests(10)
 *                 .minIdleInstances(1)
 *                 .maxIdleInstances(3)
 *                 .minPendingLatency("1s")
 *                 .maxPendingLatency("5s")
 *                 .standardSchedulerSettings(StandardAppVersionAutomaticScalingStandardSchedulerSettingsArgs.builder()
 *                     .targetCpuUtilization(0.5)
 *                     .targetThroughputUtilization(0.75)
 *                     .minInstances(2)
 *                     .maxInstances(10)
 *                     .build())
 *                 .build())
 *             .deleteServiceOnDestroy(true)
 *             .serviceAccount(customServiceAccount.email())
 *             .build());
 *         var myappV2 = new StandardAppVersion("myappV2", StandardAppVersionArgs.builder()
 *             .versionId("v2")
 *             .service("myapp")
 *             .runtime("nodejs20")
 *             .appEngineApis(true)
 *             .entrypoint(StandardAppVersionEntrypointArgs.builder()
 *                 .shell("node ./app.js")
 *                 .build())
 *             .deployment(StandardAppVersionDeploymentArgs.builder()
 *                 .zip(StandardAppVersionDeploymentZipArgs.builder()
 *                     .sourceUrl(Output.tuple(bucket.name(), object.name()).applyValue(values -> {
 *                         var bucketName = values.t1;
 *                         var objectName = values.t2;
 *                         return String.format("https://storage.googleapis.com/%s/%s", bucketName,objectName);
 *                     }))
 *                     .build())
 *                 .build())
 *             .envVariables(Map.of("port", "8080"))
 *             .basicScaling(StandardAppVersionBasicScalingArgs.builder()
 *                 .maxInstances(5)
 *                 .build())
 *             .noopOnDestroy(true)
 *             .serviceAccount(customServiceAccount.email())
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   customServiceAccount:
 *     type: gcp:serviceaccount:Account
 *     name: custom_service_account
 *     properties:
 *       accountId: my-account
 *       displayName: Custom Service Account
 *   gaeApi:
 *     type: gcp:projects:IAMMember
 *     name: gae_api
 *     properties:
 *       project: ${customServiceAccount.project}
 *       role: roles/compute.networkUser
 *       member: serviceAccount:${customServiceAccount.email}
 *   storageViewer:
 *     type: gcp:projects:IAMMember
 *     name: storage_viewer
 *     properties:
 *       project: ${customServiceAccount.project}
 *       role: roles/storage.objectViewer
 *       member: serviceAccount:${customServiceAccount.email}
 *   myappV1:
 *     type: gcp:appengine:StandardAppVersion
 *     name: myapp_v1
 *     properties:
 *       versionId: v1
 *       service: myapp
 *       runtime: nodejs20
 *       entrypoint:
 *         shell: node ./app.js
 *       deployment:
 *         zip:
 *           sourceUrl: https://storage.googleapis.com/${bucket.name}/${object.name}
 *       envVariables:
 *         port: '8080'
 *       automaticScaling:
 *         maxConcurrentRequests: 10
 *         minIdleInstances: 1
 *         maxIdleInstances: 3
 *         minPendingLatency: 1s
 *         maxPendingLatency: 5s
 *         standardSchedulerSettings:
 *           targetCpuUtilization: 0.5
 *           targetThroughputUtilization: 0.75
 *           minInstances: 2
 *           maxInstances: 10
 *       deleteServiceOnDestroy: true
 *       serviceAccount: ${customServiceAccount.email}
 *   myappV2:
 *     type: gcp:appengine:StandardAppVersion
 *     name: myapp_v2
 *     properties:
 *       versionId: v2
 *       service: myapp
 *       runtime: nodejs20
 *       appEngineApis: true
 *       entrypoint:
 *         shell: node ./app.js
 *       deployment:
 *         zip:
 *           sourceUrl: https://storage.googleapis.com/${bucket.name}/${object.name}
 *       envVariables:
 *         port: '8080'
 *       basicScaling:
 *         maxInstances: 5
 *       noopOnDestroy: true
 *       serviceAccount: ${customServiceAccount.email}
 *   bucket:
 *     type: gcp:storage:Bucket
 *     properties:
 *       name: appengine-static-content
 *       location: US
 *   object:
 *     type: gcp:storage:BucketObject
 *     properties:
 *       name: hello-world.zip
 *       bucket: ${bucket.name}
 *       source:
 *         fn::FileAsset: ./test-fixtures/hello-world.zip
 * ```
 * 
 * ## Import
 * StandardAppVersion can be imported using any of these accepted formats:
 * * `apps/{{project}}/services/{{service}}/versions/{{version_id}}`
 * * `{{project}}/{{service}}/{{version_id}}`
 * * `{{service}}/{{version_id}}`
 * When using the `pulumi import` command, StandardAppVersion can be imported using one of the formats above. For example:
 * ```sh
 * $ pulumi import gcp:appengine/standardAppVersion:StandardAppVersion default apps/{{project}}/services/{{service}}/versions/{{version_id}}
 * ```
 * ```sh
 * $ pulumi import gcp:appengine/standardAppVersion:StandardAppVersion default {{project}}/{{service}}/{{version_id}}
 * ```
 * ```sh
 * $ pulumi import gcp:appengine/standardAppVersion:StandardAppVersion default {{service}}/{{version_id}}
 * ```
 * @property appEngineApis Allows App Engine second generation runtimes to access the legacy bundled services.
 * @property automaticScaling Automatic scaling is based on request rate, response latencies, and other application metrics.
 * @property basicScaling Basic scaling creates instances when your application receives requests. Each instance will be shut down when the
 * application becomes idle. Basic scaling is ideal for work that is intermittent or driven by user activity.
 * @property deleteServiceOnDestroy If set to 'true', the service will be deleted if it is the last version.
 * @property deployment Code and application artifacts that make up this version.
 * Structure is documented below.
 * @property entrypoint The entrypoint for the application.
 * Structure is documented below.
 * @property envVariables Environment variables available to the application.
 * @property handlers An ordered list of URL-matching patterns that should be applied to incoming requests. The first matching URL handles the
 * request and other request handlers are not attempted.
 * @property inboundServices A list of the types of messages that this application is able to receive. Possible values: ["INBOUND_SERVICE_MAIL",
 * "INBOUND_SERVICE_MAIL_BOUNCE", "INBOUND_SERVICE_XMPP_ERROR", "INBOUND_SERVICE_XMPP_MESSAGE",
 * "INBOUND_SERVICE_XMPP_SUBSCRIBE", "INBOUND_SERVICE_XMPP_PRESENCE", "INBOUND_SERVICE_CHANNEL_PRESENCE",
 * "INBOUND_SERVICE_WARMUP"]
 * @property instanceClass Instance class that is used to run this version. Valid values are AutomaticScaling: F1, F2, F4, F4_1G BasicScaling or
 * ManualScaling: B1, B2, B4, B4_1G, B8 Defaults to F1 for AutomaticScaling and B2 for ManualScaling and BasicScaling. If
 * no scaling is specified, AutomaticScaling is chosen.
 * @property libraries Configuration for third-party Python runtime libraries that are required by the application.
 * @property manualScaling A service with manual scaling runs continuously, allowing you to perform complex initialization and rely on the state of
 * its memory over time.
 * @property noopOnDestroy If set to 'true', the application version will not be deleted.
 * @property project
 * @property runtime Desired runtime. Example python27.
 * @property runtimeApiVersion The version of the API in the given runtime environment. Please see the app.yaml reference for valid values at
 * 'https://cloud.google.com/appengine/docs/standard//config/appref'\ Substitute '' with 'python',
 * 'java', 'php', 'ruby', 'go' or 'nodejs'.
 * @property service AppEngine service resource
 * @property serviceAccount The identity that the deployed version will run as. Admin API will use the App Engine Appspot service account as default
 * if this field is neither provided in app.yaml file nor through CLI flag.
 * @property threadsafe Whether multiple requests can be dispatched to this version at once.
 * @property versionId Relative name of the version within the service. For example, 'v1'. Version names can contain only lowercase letters,
 * numbers, or hyphens. Reserved names,"default", "latest", and any name with the prefix "ah-".
 * @property vpcAccessConnector Enables VPC connectivity for standard apps.
 */
public data class StandardAppVersionArgs(
    public val appEngineApis: Output? = null,
    public val automaticScaling: Output? = null,
    public val basicScaling: Output? = null,
    public val deleteServiceOnDestroy: Output? = null,
    public val deployment: Output? = null,
    public val entrypoint: Output? = null,
    public val envVariables: Output>? = null,
    public val handlers: Output>? = null,
    public val inboundServices: Output>? = null,
    public val instanceClass: Output? = null,
    public val libraries: Output>? = null,
    public val manualScaling: Output? = null,
    public val noopOnDestroy: Output? = null,
    public val project: Output? = null,
    public val runtime: Output? = null,
    public val runtimeApiVersion: Output? = null,
    public val service: Output? = null,
    public val serviceAccount: Output? = null,
    public val threadsafe: Output? = null,
    public val versionId: Output? = null,
    public val vpcAccessConnector: Output? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.gcp.appengine.StandardAppVersionArgs =
        com.pulumi.gcp.appengine.StandardAppVersionArgs.builder()
            .appEngineApis(appEngineApis?.applyValue({ args0 -> args0 }))
            .automaticScaling(automaticScaling?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .basicScaling(basicScaling?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .deleteServiceOnDestroy(deleteServiceOnDestroy?.applyValue({ args0 -> args0 }))
            .deployment(deployment?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .entrypoint(entrypoint?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .envVariables(
                envVariables?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.key.to(args0.value)
                    }).toMap()
                }),
            )
            .handlers(
                handlers?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 ->
                            args0.toJava()
                        })
                    })
                }),
            )
            .inboundServices(inboundServices?.applyValue({ args0 -> args0.map({ args0 -> args0 }) }))
            .instanceClass(instanceClass?.applyValue({ args0 -> args0 }))
            .libraries(
                libraries?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 ->
                            args0.toJava()
                        })
                    })
                }),
            )
            .manualScaling(manualScaling?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .noopOnDestroy(noopOnDestroy?.applyValue({ args0 -> args0 }))
            .project(project?.applyValue({ args0 -> args0 }))
            .runtime(runtime?.applyValue({ args0 -> args0 }))
            .runtimeApiVersion(runtimeApiVersion?.applyValue({ args0 -> args0 }))
            .service(service?.applyValue({ args0 -> args0 }))
            .serviceAccount(serviceAccount?.applyValue({ args0 -> args0 }))
            .threadsafe(threadsafe?.applyValue({ args0 -> args0 }))
            .versionId(versionId?.applyValue({ args0 -> args0 }))
            .vpcAccessConnector(
                vpcAccessConnector?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            ).build()
}

/**
 * Builder for [StandardAppVersionArgs].
 */
@PulumiTagMarker
public class StandardAppVersionArgsBuilder internal constructor() {
    private var appEngineApis: Output? = null

    private var automaticScaling: Output? = null

    private var basicScaling: Output? = null

    private var deleteServiceOnDestroy: Output? = null

    private var deployment: Output? = null

    private var entrypoint: Output? = null

    private var envVariables: Output>? = null

    private var handlers: Output>? = null

    private var inboundServices: Output>? = null

    private var instanceClass: Output? = null

    private var libraries: Output>? = null

    private var manualScaling: Output? = null

    private var noopOnDestroy: Output? = null

    private var project: Output? = null

    private var runtime: Output? = null

    private var runtimeApiVersion: Output? = null

    private var service: Output? = null

    private var serviceAccount: Output? = null

    private var threadsafe: Output? = null

    private var versionId: Output? = null

    private var vpcAccessConnector: Output? = null

    /**
     * @param value Allows App Engine second generation runtimes to access the legacy bundled services.
     */
    @JvmName("dqfjnqgyxuunrpii")
    public suspend fun appEngineApis(`value`: Output) {
        this.appEngineApis = value
    }

    /**
     * @param value Automatic scaling is based on request rate, response latencies, and other application metrics.
     */
    @JvmName("mvteoalwdmejgmhs")
    public suspend fun automaticScaling(`value`: Output) {
        this.automaticScaling = value
    }

    /**
     * @param value Basic scaling creates instances when your application receives requests. Each instance will be shut down when the
     * application becomes idle. Basic scaling is ideal for work that is intermittent or driven by user activity.
     */
    @JvmName("psuolqfkakwbmcxw")
    public suspend fun basicScaling(`value`: Output) {
        this.basicScaling = value
    }

    /**
     * @param value If set to 'true', the service will be deleted if it is the last version.
     */
    @JvmName("ofpaqxuxxsvtxrir")
    public suspend fun deleteServiceOnDestroy(`value`: Output) {
        this.deleteServiceOnDestroy = value
    }

    /**
     * @param value Code and application artifacts that make up this version.
     * Structure is documented below.
     */
    @JvmName("oobvimhjqygdytom")
    public suspend fun deployment(`value`: Output) {
        this.deployment = value
    }

    /**
     * @param value The entrypoint for the application.
     * Structure is documented below.
     */
    @JvmName("cjkrbftclohljqrs")
    public suspend fun entrypoint(`value`: Output) {
        this.entrypoint = value
    }

    /**
     * @param value Environment variables available to the application.
     */
    @JvmName("soxetbmrmhfnhwjj")
    public suspend fun envVariables(`value`: Output>) {
        this.envVariables = value
    }

    /**
     * @param value An ordered list of URL-matching patterns that should be applied to incoming requests. The first matching URL handles the
     * request and other request handlers are not attempted.
     */
    @JvmName("nepvipvbxlgeduiq")
    public suspend fun handlers(`value`: Output>) {
        this.handlers = value
    }

    @JvmName("ytlyjofmsaynyghf")
    public suspend fun handlers(vararg values: Output) {
        this.handlers = Output.all(values.asList())
    }

    /**
     * @param values An ordered list of URL-matching patterns that should be applied to incoming requests. The first matching URL handles the
     * request and other request handlers are not attempted.
     */
    @JvmName("rnspkrctjjudpwxg")
    public suspend fun handlers(values: List>) {
        this.handlers = Output.all(values)
    }

    /**
     * @param value A list of the types of messages that this application is able to receive. Possible values: ["INBOUND_SERVICE_MAIL",
     * "INBOUND_SERVICE_MAIL_BOUNCE", "INBOUND_SERVICE_XMPP_ERROR", "INBOUND_SERVICE_XMPP_MESSAGE",
     * "INBOUND_SERVICE_XMPP_SUBSCRIBE", "INBOUND_SERVICE_XMPP_PRESENCE", "INBOUND_SERVICE_CHANNEL_PRESENCE",
     * "INBOUND_SERVICE_WARMUP"]
     */
    @JvmName("iuivajqyfyirhijh")
    public suspend fun inboundServices(`value`: Output>) {
        this.inboundServices = value
    }

    @JvmName("yidivewhukahepug")
    public suspend fun inboundServices(vararg values: Output) {
        this.inboundServices = Output.all(values.asList())
    }

    /**
     * @param values A list of the types of messages that this application is able to receive. Possible values: ["INBOUND_SERVICE_MAIL",
     * "INBOUND_SERVICE_MAIL_BOUNCE", "INBOUND_SERVICE_XMPP_ERROR", "INBOUND_SERVICE_XMPP_MESSAGE",
     * "INBOUND_SERVICE_XMPP_SUBSCRIBE", "INBOUND_SERVICE_XMPP_PRESENCE", "INBOUND_SERVICE_CHANNEL_PRESENCE",
     * "INBOUND_SERVICE_WARMUP"]
     */
    @JvmName("edbycekawtsayyvv")
    public suspend fun inboundServices(values: List>) {
        this.inboundServices = Output.all(values)
    }

    /**
     * @param value Instance class that is used to run this version. Valid values are AutomaticScaling: F1, F2, F4, F4_1G BasicScaling or
     * ManualScaling: B1, B2, B4, B4_1G, B8 Defaults to F1 for AutomaticScaling and B2 for ManualScaling and BasicScaling. If
     * no scaling is specified, AutomaticScaling is chosen.
     */
    @JvmName("edyjljjpjfrpxkas")
    public suspend fun instanceClass(`value`: Output) {
        this.instanceClass = value
    }

    /**
     * @param value Configuration for third-party Python runtime libraries that are required by the application.
     */
    @JvmName("ukemfqvoggwmmuia")
    public suspend fun libraries(`value`: Output>) {
        this.libraries = value
    }

    @JvmName("aeqphbiiipnarulu")
    public suspend fun libraries(vararg values: Output) {
        this.libraries = Output.all(values.asList())
    }

    /**
     * @param values Configuration for third-party Python runtime libraries that are required by the application.
     */
    @JvmName("qibxeyorjtscthau")
    public suspend fun libraries(values: List>) {
        this.libraries = Output.all(values)
    }

    /**
     * @param value A service with manual scaling runs continuously, allowing you to perform complex initialization and rely on the state of
     * its memory over time.
     */
    @JvmName("kadraukaxlryqdko")
    public suspend fun manualScaling(`value`: Output) {
        this.manualScaling = value
    }

    /**
     * @param value If set to 'true', the application version will not be deleted.
     */
    @JvmName("xnqwckyujtlevort")
    public suspend fun noopOnDestroy(`value`: Output) {
        this.noopOnDestroy = value
    }

    /**
     * @param value
     */
    @JvmName("cabtmqbxrfwunbpn")
    public suspend fun project(`value`: Output) {
        this.project = value
    }

    /**
     * @param value Desired runtime. Example python27.
     */
    @JvmName("eralanjonyuutwbp")
    public suspend fun runtime(`value`: Output) {
        this.runtime = value
    }

    /**
     * @param value The version of the API in the given runtime environment. Please see the app.yaml reference for valid values at
     * 'https://cloud.google.com/appengine/docs/standard//config/appref'\ Substitute '' with 'python',
     * 'java', 'php', 'ruby', 'go' or 'nodejs'.
     */
    @JvmName("fgnakkwmrctdtwlk")
    public suspend fun runtimeApiVersion(`value`: Output) {
        this.runtimeApiVersion = value
    }

    /**
     * @param value AppEngine service resource
     */
    @JvmName("laaigqajqvmbaqyr")
    public suspend fun service(`value`: Output) {
        this.service = value
    }

    /**
     * @param value The identity that the deployed version will run as. Admin API will use the App Engine Appspot service account as default
     * if this field is neither provided in app.yaml file nor through CLI flag.
     */
    @JvmName("yfheoruxhmnlahkw")
    public suspend fun serviceAccount(`value`: Output) {
        this.serviceAccount = value
    }

    /**
     * @param value Whether multiple requests can be dispatched to this version at once.
     */
    @JvmName("jyevkeckirjohupm")
    public suspend fun threadsafe(`value`: Output) {
        this.threadsafe = value
    }

    /**
     * @param value Relative name of the version within the service. For example, 'v1'. Version names can contain only lowercase letters,
     * numbers, or hyphens. Reserved names,"default", "latest", and any name with the prefix "ah-".
     */
    @JvmName("gnmdfafsdkxvkkls")
    public suspend fun versionId(`value`: Output) {
        this.versionId = value
    }

    /**
     * @param value Enables VPC connectivity for standard apps.
     */
    @JvmName("dchvxdfmulqgjytd")
    public suspend fun vpcAccessConnector(`value`: Output) {
        this.vpcAccessConnector = value
    }

    /**
     * @param value Allows App Engine second generation runtimes to access the legacy bundled services.
     */
    @JvmName("gsfitkpmnycwblty")
    public suspend fun appEngineApis(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.appEngineApis = mapped
    }

    /**
     * @param value Automatic scaling is based on request rate, response latencies, and other application metrics.
     */
    @JvmName("rjqommemwwaoames")
    public suspend fun automaticScaling(`value`: StandardAppVersionAutomaticScalingArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.automaticScaling = mapped
    }

    /**
     * @param argument Automatic scaling is based on request rate, response latencies, and other application metrics.
     */
    @JvmName("gssfrijgkpgepfsj")
    public suspend fun automaticScaling(argument: suspend StandardAppVersionAutomaticScalingArgsBuilder.() -> Unit) {
        val toBeMapped = StandardAppVersionAutomaticScalingArgsBuilder().applySuspend {
            argument()
        }.build()
        val mapped = of(toBeMapped)
        this.automaticScaling = mapped
    }

    /**
     * @param value Basic scaling creates instances when your application receives requests. Each instance will be shut down when the
     * application becomes idle. Basic scaling is ideal for work that is intermittent or driven by user activity.
     */
    @JvmName("qjmhyofefrayfxux")
    public suspend fun basicScaling(`value`: StandardAppVersionBasicScalingArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.basicScaling = mapped
    }

    /**
     * @param argument Basic scaling creates instances when your application receives requests. Each instance will be shut down when the
     * application becomes idle. Basic scaling is ideal for work that is intermittent or driven by user activity.
     */
    @JvmName("tlsrkyrjgtudvsub")
    public suspend fun basicScaling(argument: suspend StandardAppVersionBasicScalingArgsBuilder.() -> Unit) {
        val toBeMapped = StandardAppVersionBasicScalingArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.basicScaling = mapped
    }

    /**
     * @param value If set to 'true', the service will be deleted if it is the last version.
     */
    @JvmName("pinvdubxsfffunuc")
    public suspend fun deleteServiceOnDestroy(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.deleteServiceOnDestroy = mapped
    }

    /**
     * @param value Code and application artifacts that make up this version.
     * Structure is documented below.
     */
    @JvmName("ryehgyycvrisevnf")
    public suspend fun deployment(`value`: StandardAppVersionDeploymentArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.deployment = mapped
    }

    /**
     * @param argument Code and application artifacts that make up this version.
     * Structure is documented below.
     */
    @JvmName("ogcnufcmvjroennb")
    public suspend fun deployment(argument: suspend StandardAppVersionDeploymentArgsBuilder.() -> Unit) {
        val toBeMapped = StandardAppVersionDeploymentArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.deployment = mapped
    }

    /**
     * @param value The entrypoint for the application.
     * Structure is documented below.
     */
    @JvmName("cxddciebitctbckq")
    public suspend fun entrypoint(`value`: StandardAppVersionEntrypointArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.entrypoint = mapped
    }

    /**
     * @param argument The entrypoint for the application.
     * Structure is documented below.
     */
    @JvmName("lbackiibbgmbubxo")
    public suspend fun entrypoint(argument: suspend StandardAppVersionEntrypointArgsBuilder.() -> Unit) {
        val toBeMapped = StandardAppVersionEntrypointArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.entrypoint = mapped
    }

    /**
     * @param value Environment variables available to the application.
     */
    @JvmName("yqahdjpbjahaawtl")
    public suspend fun envVariables(`value`: Map?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.envVariables = mapped
    }

    /**
     * @param values Environment variables available to the application.
     */
    @JvmName("ihsiwlkahpwdyeds")
    public fun envVariables(vararg values: Pair) {
        val toBeMapped = values.toMap()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.envVariables = mapped
    }

    /**
     * @param value An ordered list of URL-matching patterns that should be applied to incoming requests. The first matching URL handles the
     * request and other request handlers are not attempted.
     */
    @JvmName("tntttqawpymeenmf")
    public suspend fun handlers(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.handlers = mapped
    }

    /**
     * @param argument An ordered list of URL-matching patterns that should be applied to incoming requests. The first matching URL handles the
     * request and other request handlers are not attempted.
     */
    @JvmName("hyjvdecuyxkjtjji")
    public suspend fun handlers(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            StandardAppVersionHandlerArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.handlers = mapped
    }

    /**
     * @param argument An ordered list of URL-matching patterns that should be applied to incoming requests. The first matching URL handles the
     * request and other request handlers are not attempted.
     */
    @JvmName("fawcfljdehfvafbf")
    public suspend fun handlers(vararg argument: suspend StandardAppVersionHandlerArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            StandardAppVersionHandlerArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.handlers = mapped
    }

    /**
     * @param argument An ordered list of URL-matching patterns that should be applied to incoming requests. The first matching URL handles the
     * request and other request handlers are not attempted.
     */
    @JvmName("viiybajkwqwmxnbt")
    public suspend fun handlers(argument: suspend StandardAppVersionHandlerArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(
            StandardAppVersionHandlerArgsBuilder().applySuspend {
                argument()
            }.build(),
        )
        val mapped = of(toBeMapped)
        this.handlers = mapped
    }

    /**
     * @param values An ordered list of URL-matching patterns that should be applied to incoming requests. The first matching URL handles the
     * request and other request handlers are not attempted.
     */
    @JvmName("wdyuxtgnixratrpq")
    public suspend fun handlers(vararg values: StandardAppVersionHandlerArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.handlers = mapped
    }

    /**
     * @param value A list of the types of messages that this application is able to receive. Possible values: ["INBOUND_SERVICE_MAIL",
     * "INBOUND_SERVICE_MAIL_BOUNCE", "INBOUND_SERVICE_XMPP_ERROR", "INBOUND_SERVICE_XMPP_MESSAGE",
     * "INBOUND_SERVICE_XMPP_SUBSCRIBE", "INBOUND_SERVICE_XMPP_PRESENCE", "INBOUND_SERVICE_CHANNEL_PRESENCE",
     * "INBOUND_SERVICE_WARMUP"]
     */
    @JvmName("cheivcnltbfdjedg")
    public suspend fun inboundServices(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.inboundServices = mapped
    }

    /**
     * @param values A list of the types of messages that this application is able to receive. Possible values: ["INBOUND_SERVICE_MAIL",
     * "INBOUND_SERVICE_MAIL_BOUNCE", "INBOUND_SERVICE_XMPP_ERROR", "INBOUND_SERVICE_XMPP_MESSAGE",
     * "INBOUND_SERVICE_XMPP_SUBSCRIBE", "INBOUND_SERVICE_XMPP_PRESENCE", "INBOUND_SERVICE_CHANNEL_PRESENCE",
     * "INBOUND_SERVICE_WARMUP"]
     */
    @JvmName("nkhbuentwqhtopul")
    public suspend fun inboundServices(vararg values: String) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.inboundServices = mapped
    }

    /**
     * @param value Instance class that is used to run this version. Valid values are AutomaticScaling: F1, F2, F4, F4_1G BasicScaling or
     * ManualScaling: B1, B2, B4, B4_1G, B8 Defaults to F1 for AutomaticScaling and B2 for ManualScaling and BasicScaling. If
     * no scaling is specified, AutomaticScaling is chosen.
     */
    @JvmName("tjsxtqxwpmybvacd")
    public suspend fun instanceClass(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.instanceClass = mapped
    }

    /**
     * @param value Configuration for third-party Python runtime libraries that are required by the application.
     */
    @JvmName("sirfnaydirvsqgbe")
    public suspend fun libraries(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.libraries = mapped
    }

    /**
     * @param argument Configuration for third-party Python runtime libraries that are required by the application.
     */
    @JvmName("wbfsvcqaskpmjhei")
    public suspend fun libraries(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            StandardAppVersionLibraryArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.libraries = mapped
    }

    /**
     * @param argument Configuration for third-party Python runtime libraries that are required by the application.
     */
    @JvmName("nlduomhelythlpce")
    public suspend fun libraries(vararg argument: suspend StandardAppVersionLibraryArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            StandardAppVersionLibraryArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.libraries = mapped
    }

    /**
     * @param argument Configuration for third-party Python runtime libraries that are required by the application.
     */
    @JvmName("uscosdyffdantgjy")
    public suspend fun libraries(argument: suspend StandardAppVersionLibraryArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(
            StandardAppVersionLibraryArgsBuilder().applySuspend {
                argument()
            }.build(),
        )
        val mapped = of(toBeMapped)
        this.libraries = mapped
    }

    /**
     * @param values Configuration for third-party Python runtime libraries that are required by the application.
     */
    @JvmName("idfwwoqecuupvpgk")
    public suspend fun libraries(vararg values: StandardAppVersionLibraryArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.libraries = mapped
    }

    /**
     * @param value A service with manual scaling runs continuously, allowing you to perform complex initialization and rely on the state of
     * its memory over time.
     */
    @JvmName("pdikfsydrclgqthw")
    public suspend fun manualScaling(`value`: StandardAppVersionManualScalingArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.manualScaling = mapped
    }

    /**
     * @param argument A service with manual scaling runs continuously, allowing you to perform complex initialization and rely on the state of
     * its memory over time.
     */
    @JvmName("frerdkxxiqelojow")
    public suspend fun manualScaling(argument: suspend StandardAppVersionManualScalingArgsBuilder.() -> Unit) {
        val toBeMapped = StandardAppVersionManualScalingArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.manualScaling = mapped
    }

    /**
     * @param value If set to 'true', the application version will not be deleted.
     */
    @JvmName("ufuwiprluxvjkhog")
    public suspend fun noopOnDestroy(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.noopOnDestroy = mapped
    }

    /**
     * @param value
     */
    @JvmName("dgkbyteqrhfgmsif")
    public suspend fun project(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.project = mapped
    }

    /**
     * @param value Desired runtime. Example python27.
     */
    @JvmName("lpfayqwyfrqlvbqh")
    public suspend fun runtime(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.runtime = mapped
    }

    /**
     * @param value The version of the API in the given runtime environment. Please see the app.yaml reference for valid values at
     * 'https://cloud.google.com/appengine/docs/standard//config/appref'\ Substitute '' with 'python',
     * 'java', 'php', 'ruby', 'go' or 'nodejs'.
     */
    @JvmName("ihsqmonuddpjnqih")
    public suspend fun runtimeApiVersion(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.runtimeApiVersion = mapped
    }

    /**
     * @param value AppEngine service resource
     */
    @JvmName("ywgamvodvfgsucjc")
    public suspend fun service(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.service = mapped
    }

    /**
     * @param value The identity that the deployed version will run as. Admin API will use the App Engine Appspot service account as default
     * if this field is neither provided in app.yaml file nor through CLI flag.
     */
    @JvmName("ysqrtcyxywquxpdo")
    public suspend fun serviceAccount(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.serviceAccount = mapped
    }

    /**
     * @param value Whether multiple requests can be dispatched to this version at once.
     */
    @JvmName("sbocgejhaoprwgal")
    public suspend fun threadsafe(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.threadsafe = mapped
    }

    /**
     * @param value Relative name of the version within the service. For example, 'v1'. Version names can contain only lowercase letters,
     * numbers, or hyphens. Reserved names,"default", "latest", and any name with the prefix "ah-".
     */
    @JvmName("nbohojlmlyvnatgw")
    public suspend fun versionId(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.versionId = mapped
    }

    /**
     * @param value Enables VPC connectivity for standard apps.
     */
    @JvmName("teqoughjadmscyuh")
    public suspend fun vpcAccessConnector(`value`: StandardAppVersionVpcAccessConnectorArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.vpcAccessConnector = mapped
    }

    /**
     * @param argument Enables VPC connectivity for standard apps.
     */
    @JvmName("hdmfktqdrbbigxsh")
    public suspend fun vpcAccessConnector(argument: suspend StandardAppVersionVpcAccessConnectorArgsBuilder.() -> Unit) {
        val toBeMapped = StandardAppVersionVpcAccessConnectorArgsBuilder().applySuspend {
            argument()
        }.build()
        val mapped = of(toBeMapped)
        this.vpcAccessConnector = mapped
    }

    internal fun build(): StandardAppVersionArgs = StandardAppVersionArgs(
        appEngineApis = appEngineApis,
        automaticScaling = automaticScaling,
        basicScaling = basicScaling,
        deleteServiceOnDestroy = deleteServiceOnDestroy,
        deployment = deployment,
        entrypoint = entrypoint,
        envVariables = envVariables,
        handlers = handlers,
        inboundServices = inboundServices,
        instanceClass = instanceClass,
        libraries = libraries,
        manualScaling = manualScaling,
        noopOnDestroy = noopOnDestroy,
        project = project,
        runtime = runtime,
        runtimeApiVersion = runtimeApiVersion,
        service = service,
        serviceAccount = serviceAccount,
        threadsafe = threadsafe,
        versionId = versionId,
        vpcAccessConnector = vpcAccessConnector,
    )
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy