pulumi-gcp 6.68.0a1697867869__py3-none-any.whl → 6.68.0a1698199636__py3-none-any.whl

pulumi_gcp/appengine/outputs.py

@@ -89,8 +89,14 @@ class ApplicationFeatureSettings(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             split_health_checks: bool,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             split_health_checks: Optional[bool] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if split_health_checks is None and 'splitHealthChecks' in kwargs:
+            split_health_checks = kwargs['splitHealthChecks']
+        if split_health_checks is None:
+            raise TypeError("Missing 'split_health_checks' argument")
+
         _setter("split_health_checks", split_health_checks)
 
     @property
@@ -149,11 +155,23 @@ class ApplicationIap(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             oauth2_client_id: str,
-             oauth2_client_secret: str,
+             oauth2_client_id: Optional[str] = None,
+             oauth2_client_secret: Optional[str] = None,
              enabled: Optional[bool] = None,
              oauth2_client_secret_sha256: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if oauth2_client_id is None and 'oauth2ClientId' in kwargs:
+            oauth2_client_id = kwargs['oauth2ClientId']
+        if oauth2_client_id is None:
+            raise TypeError("Missing 'oauth2_client_id' argument")
+        if oauth2_client_secret is None and 'oauth2ClientSecret' in kwargs:
+            oauth2_client_secret = kwargs['oauth2ClientSecret']
+        if oauth2_client_secret is None:
+            raise TypeError("Missing 'oauth2_client_secret' argument")
+        if oauth2_client_secret_sha256 is None and 'oauth2ClientSecretSha256' in kwargs:
+            oauth2_client_secret_sha256 = kwargs['oauth2ClientSecretSha256']
+
         _setter("oauth2_client_id", oauth2_client_id)
         _setter("oauth2_client_secret", oauth2_client_secret)
         if enabled is not None:
@@ -214,7 +232,9 @@ class ApplicationUrlDispatchRule(dict):
              domain: Optional[str] = None,
              path: Optional[str] = None,
              service: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+
         if domain is not None:
             _setter("domain", domain)
         if path is not None:
@@ -263,10 +283,16 @@ class ApplicationUrlDispatchRulesDispatchRule(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             path: str,
-             service: str,
+             path: Optional[str] = None,
+             service: Optional[str] = None,
              domain: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if path is None:
+            raise TypeError("Missing 'path' argument")
+        if service is None:
+            raise TypeError("Missing 'service' argument")
+
         _setter("path", path)
         _setter("service", service)
         if domain is not None:
@@ -326,7 +352,9 @@ class DomainMappingResourceRecord(dict):
              name: Optional[str] = None,
              rrdata: Optional[str] = None,
              type: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+
         if name is not None:
             _setter("name", name)
         if rrdata is not None:
@@ -413,10 +441,20 @@ class DomainMappingSslSettings(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             ssl_management_type: str,
+             ssl_management_type: Optional[str] = None,
              certificate_id: Optional[str] = None,
              pending_managed_certificate_id: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if ssl_management_type is None and 'sslManagementType' in kwargs:
+            ssl_management_type = kwargs['sslManagementType']
+        if ssl_management_type is None:
+            raise TypeError("Missing 'ssl_management_type' argument")
+        if certificate_id is None and 'certificateId' in kwargs:
+            certificate_id = kwargs['certificateId']
+        if pending_managed_certificate_id is None and 'pendingManagedCertificateId' in kwargs:
+            pending_managed_certificate_id = kwargs['pendingManagedCertificateId']
+
         _setter("ssl_management_type", ssl_management_type)
         if certificate_id is not None:
             _setter("certificate_id", certificate_id)
@@ -497,9 +535,15 @@ class EngineSplitTrafficSplit(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             allocations: Mapping[str, str],
+             allocations: Optional[Mapping[str, str]] = None,
              shard_by: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if allocations is None:
+            raise TypeError("Missing 'allocations' argument")
+        if shard_by is None and 'shardBy' in kwargs:
+            shard_by = kwargs['shardBy']
+
         _setter("allocations", allocations)
         if shard_by is not None:
             _setter("shard_by", shard_by)
@@ -574,12 +618,20 @@ class FlexibleAppVersionApiConfig(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             script: str,
+             script: Optional[str] = None,
              auth_fail_action: Optional[str] = None,
              login: Optional[str] = None,
              security_level: Optional[str] = None,
              url: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if script is None:
+            raise TypeError("Missing 'script' argument")
+        if auth_fail_action is None and 'authFailAction' in kwargs:
+            auth_fail_action = kwargs['authFailAction']
+        if security_level is None and 'securityLevel' in kwargs:
+            security_level = kwargs['securityLevel']
+
         _setter("script", script)
         if auth_fail_action is not None:
             _setter("auth_fail_action", auth_fail_action)
@@ -729,7 +781,7 @@ class FlexibleAppVersionAutomaticScaling(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             cpu_utilization: 'outputs.FlexibleAppVersionAutomaticScalingCpuUtilization',
+             cpu_utilization: Optional['outputs.FlexibleAppVersionAutomaticScalingCpuUtilization'] = None,
              cool_down_period: Optional[str] = None,
              disk_utilization: Optional['outputs.FlexibleAppVersionAutomaticScalingDiskUtilization'] = None,
              max_concurrent_requests: Optional[int] = None,
@@ -741,7 +793,35 @@ class FlexibleAppVersionAutomaticScaling(dict):
              min_total_instances: Optional[int] = None,
              network_utilization: Optional['outputs.FlexibleAppVersionAutomaticScalingNetworkUtilization'] = None,
              request_utilization: Optional['outputs.FlexibleAppVersionAutomaticScalingRequestUtilization'] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if cpu_utilization is None and 'cpuUtilization' in kwargs:
+            cpu_utilization = kwargs['cpuUtilization']
+        if cpu_utilization is None:
+            raise TypeError("Missing 'cpu_utilization' argument")
+        if cool_down_period is None and 'coolDownPeriod' in kwargs:
+            cool_down_period = kwargs['coolDownPeriod']
+        if disk_utilization is None and 'diskUtilization' in kwargs:
+            disk_utilization = kwargs['diskUtilization']
+        if max_concurrent_requests is None and 'maxConcurrentRequests' in kwargs:
+            max_concurrent_requests = kwargs['maxConcurrentRequests']
+        if max_idle_instances is None and 'maxIdleInstances' in kwargs:
+            max_idle_instances = kwargs['maxIdleInstances']
+        if max_pending_latency is None and 'maxPendingLatency' in kwargs:
+            max_pending_latency = kwargs['maxPendingLatency']
+        if max_total_instances is None and 'maxTotalInstances' in kwargs:
+            max_total_instances = kwargs['maxTotalInstances']
+        if min_idle_instances is None and 'minIdleInstances' in kwargs:
+            min_idle_instances = kwargs['minIdleInstances']
+        if min_pending_latency is None and 'minPendingLatency' in kwargs:
+            min_pending_latency = kwargs['minPendingLatency']
+        if min_total_instances is None and 'minTotalInstances' in kwargs:
+            min_total_instances = kwargs['minTotalInstances']
+        if network_utilization is None and 'networkUtilization' in kwargs:
+            network_utilization = kwargs['networkUtilization']
+        if request_utilization is None and 'requestUtilization' in kwargs:
+            request_utilization = kwargs['requestUtilization']
+
         _setter("cpu_utilization", cpu_utilization)
         if cool_down_period is not None:
             _setter("cool_down_period", cool_down_period)
@@ -906,9 +986,17 @@ class FlexibleAppVersionAutomaticScalingCpuUtilization(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             target_utilization: float,
+             target_utilization: Optional[float] = None,
              aggregation_window_length: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if target_utilization is None and 'targetUtilization' in kwargs:
+            target_utilization = kwargs['targetUtilization']
+        if target_utilization is None:
+            raise TypeError("Missing 'target_utilization' argument")
+        if aggregation_window_length is None and 'aggregationWindowLength' in kwargs:
+            aggregation_window_length = kwargs['aggregationWindowLength']
+
         _setter("target_utilization", target_utilization)
         if aggregation_window_length is not None:
             _setter("aggregation_window_length", aggregation_window_length)
@@ -980,7 +1068,17 @@ class FlexibleAppVersionAutomaticScalingDiskUtilization(dict):
              target_read_ops_per_second: Optional[int] = None,
              target_write_bytes_per_second: Optional[int] = None,
              target_write_ops_per_second: Optional[int] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if target_read_bytes_per_second is None and 'targetReadBytesPerSecond' in kwargs:
+            target_read_bytes_per_second = kwargs['targetReadBytesPerSecond']
+        if target_read_ops_per_second is None and 'targetReadOpsPerSecond' in kwargs:
+            target_read_ops_per_second = kwargs['targetReadOpsPerSecond']
+        if target_write_bytes_per_second is None and 'targetWriteBytesPerSecond' in kwargs:
+            target_write_bytes_per_second = kwargs['targetWriteBytesPerSecond']
+        if target_write_ops_per_second is None and 'targetWriteOpsPerSecond' in kwargs:
+            target_write_ops_per_second = kwargs['targetWriteOpsPerSecond']
+
         if target_read_bytes_per_second is not None:
             _setter("target_read_bytes_per_second", target_read_bytes_per_second)
         if target_read_ops_per_second is not None:
@@ -1073,7 +1171,17 @@ class FlexibleAppVersionAutomaticScalingNetworkUtilization(dict):
              target_received_packets_per_second: Optional[int] = None,
              target_sent_bytes_per_second: Optional[int] = None,
              target_sent_packets_per_second: Optional[int] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if target_received_bytes_per_second is None and 'targetReceivedBytesPerSecond' in kwargs:
+            target_received_bytes_per_second = kwargs['targetReceivedBytesPerSecond']
+        if target_received_packets_per_second is None and 'targetReceivedPacketsPerSecond' in kwargs:
+            target_received_packets_per_second = kwargs['targetReceivedPacketsPerSecond']
+        if target_sent_bytes_per_second is None and 'targetSentBytesPerSecond' in kwargs:
+            target_sent_bytes_per_second = kwargs['targetSentBytesPerSecond']
+        if target_sent_packets_per_second is None and 'targetSentPacketsPerSecond' in kwargs:
+            target_sent_packets_per_second = kwargs['targetSentPacketsPerSecond']
+
         if target_received_bytes_per_second is not None:
             _setter("target_received_bytes_per_second", target_received_bytes_per_second)
         if target_received_packets_per_second is not None:
@@ -1154,7 +1262,13 @@ class FlexibleAppVersionAutomaticScalingRequestUtilization(dict):
              _setter: Callable[[Any, Any], None],
              target_concurrent_requests: Optional[float] = None,
              target_request_count_per_second: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if target_concurrent_requests is None and 'targetConcurrentRequests' in kwargs:
+            target_concurrent_requests = kwargs['targetConcurrentRequests']
+        if target_request_count_per_second is None and 'targetRequestCountPerSecond' in kwargs:
+            target_request_count_per_second = kwargs['targetRequestCountPerSecond']
+
         if target_concurrent_requests is not None:
             _setter("target_concurrent_requests", target_concurrent_requests)
         if target_request_count_per_second is not None:
@@ -1226,7 +1340,11 @@ class FlexibleAppVersionDeployment(dict):
              container: Optional['outputs.FlexibleAppVersionDeploymentContainer'] = None,
              files: Optional[Sequence['outputs.FlexibleAppVersionDeploymentFile']] = None,
              zip: Optional['outputs.FlexibleAppVersionDeploymentZip'] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if cloud_build_options is None and 'cloudBuildOptions' in kwargs:
+            cloud_build_options = kwargs['cloudBuildOptions']
+
         if cloud_build_options is not None:
             _setter("cloud_build_options", cloud_build_options)
         if container is not None:
@@ -1311,9 +1429,17 @@ class FlexibleAppVersionDeploymentCloudBuildOptions(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             app_yaml_path: str,
+             app_yaml_path: Optional[str] = None,
              cloud_build_timeout: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if app_yaml_path is None and 'appYamlPath' in kwargs:
+            app_yaml_path = kwargs['appYamlPath']
+        if app_yaml_path is None:
+            raise TypeError("Missing 'app_yaml_path' argument")
+        if cloud_build_timeout is None and 'cloudBuildTimeout' in kwargs:
+            cloud_build_timeout = kwargs['cloudBuildTimeout']
+
         _setter("app_yaml_path", app_yaml_path)
         if cloud_build_timeout is not None:
             _setter("cloud_build_timeout", cloud_build_timeout)
@@ -1351,8 +1477,12 @@ class FlexibleAppVersionDeploymentContainer(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             image: str,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             image: Optional[str] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if image is None:
+            raise TypeError("Missing 'image' argument")
+
         _setter("image", image)
 
     @property
@@ -1404,10 +1534,20 @@ class FlexibleAppVersionDeploymentFile(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             name: str,
-             source_url: str,
+             name: Optional[str] = None,
+             source_url: Optional[str] = None,
              sha1_sum: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if name is None:
+            raise TypeError("Missing 'name' argument")
+        if source_url is None and 'sourceUrl' in kwargs:
+            source_url = kwargs['sourceUrl']
+        if source_url is None:
+            raise TypeError("Missing 'source_url' argument")
+        if sha1_sum is None and 'sha1Sum' in kwargs:
+            sha1_sum = kwargs['sha1Sum']
+
         _setter("name", name)
         _setter("source_url", source_url)
         if sha1_sum is not None:
@@ -1474,9 +1614,17 @@ class FlexibleAppVersionDeploymentZip(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             source_url: str,
+             source_url: Optional[str] = None,
              files_count: Optional[int] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if source_url is None and 'sourceUrl' in kwargs:
+            source_url = kwargs['sourceUrl']
+        if source_url is None:
+            raise TypeError("Missing 'source_url' argument")
+        if files_count is None and 'filesCount' in kwargs:
+            files_count = kwargs['filesCount']
+
         _setter("source_url", source_url)
         if files_count is not None:
             _setter("files_count", files_count)
@@ -1550,11 +1698,21 @@ class FlexibleAppVersionEndpointsApiService(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             name: str,
+             name: Optional[str] = None,
              config_id: Optional[str] = None,
              disable_trace_sampling: Optional[bool] = None,
              rollout_strategy: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if name is None:
+            raise TypeError("Missing 'name' argument")
+        if config_id is None and 'configId' in kwargs:
+            config_id = kwargs['configId']
+        if disable_trace_sampling is None and 'disableTraceSampling' in kwargs:
+            disable_trace_sampling = kwargs['disableTraceSampling']
+        if rollout_strategy is None and 'rolloutStrategy' in kwargs:
+            rollout_strategy = kwargs['rolloutStrategy']
+
         _setter("name", name)
         if config_id is not None:
             _setter("config_id", config_id)
@@ -1618,8 +1776,12 @@ class FlexibleAppVersionEntrypoint(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             shell: str,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             shell: Optional[str] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if shell is None:
+            raise TypeError("Missing 'shell' argument")
+
         _setter("shell", shell)
 
     @property
@@ -1704,7 +1866,19 @@ class FlexibleAppVersionHandler(dict):
              security_level: Optional[str] = None,
              static_files: Optional['outputs.FlexibleAppVersionHandlerStaticFiles'] = None,
              url_regex: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if auth_fail_action is None and 'authFailAction' in kwargs:
+            auth_fail_action = kwargs['authFailAction']
+        if redirect_http_response_code is None and 'redirectHttpResponseCode' in kwargs:
+            redirect_http_response_code = kwargs['redirectHttpResponseCode']
+        if security_level is None and 'securityLevel' in kwargs:
+            security_level = kwargs['securityLevel']
+        if static_files is None and 'staticFiles' in kwargs:
+            static_files = kwargs['staticFiles']
+        if url_regex is None and 'urlRegex' in kwargs:
+            url_regex = kwargs['urlRegex']
+
         if auth_fail_action is not None:
             _setter("auth_fail_action", auth_fail_action)
         if login is not None:
@@ -1817,8 +1991,14 @@ class FlexibleAppVersionHandlerScript(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             script_path: str,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             script_path: Optional[str] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if script_path is None and 'scriptPath' in kwargs:
+            script_path = kwargs['scriptPath']
+        if script_path is None:
+            raise TypeError("Missing 'script_path' argument")
+
         _setter("script_path", script_path)
 
     @property
@@ -1901,7 +2081,19 @@ class FlexibleAppVersionHandlerStaticFiles(dict):
              path: Optional[str] = None,
              require_matching_file: Optional[bool] = None,
              upload_path_regex: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if application_readable is None and 'applicationReadable' in kwargs:
+            application_readable = kwargs['applicationReadable']
+        if http_headers is None and 'httpHeaders' in kwargs:
+            http_headers = kwargs['httpHeaders']
+        if mime_type is None and 'mimeType' in kwargs:
+            mime_type = kwargs['mimeType']
+        if require_matching_file is None and 'requireMatchingFile' in kwargs:
+            require_matching_file = kwargs['requireMatchingFile']
+        if upload_path_regex is None and 'uploadPathRegex' in kwargs:
+            upload_path_regex = kwargs['uploadPathRegex']
+
         if application_readable is not None:
             _setter("application_readable", application_readable)
         if expiration is not None:
@@ -2038,14 +2230,26 @@ class FlexibleAppVersionLivenessCheck(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             path: str,
+             path: Optional[str] = None,
              check_interval: Optional[str] = None,
              failure_threshold: Optional[float] = None,
              host: Optional[str] = None,
              initial_delay: Optional[str] = None,
              success_threshold: Optional[float] = None,
              timeout: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if path is None:
+            raise TypeError("Missing 'path' argument")
+        if check_interval is None and 'checkInterval' in kwargs:
+            check_interval = kwargs['checkInterval']
+        if failure_threshold is None and 'failureThreshold' in kwargs:
+            failure_threshold = kwargs['failureThreshold']
+        if initial_delay is None and 'initialDelay' in kwargs:
+            initial_delay = kwargs['initialDelay']
+        if success_threshold is None and 'successThreshold' in kwargs:
+            success_threshold = kwargs['successThreshold']
+
         _setter("path", path)
         if check_interval is not None:
             _setter("check_interval", check_interval)
@@ -2135,8 +2339,12 @@ class FlexibleAppVersionManualScaling(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             instances: int,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             instances: Optional[int] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if instances is None:
+            raise TypeError("Missing 'instances' argument")
+
         _setter("instances", instances)
 
     @property
@@ -2201,12 +2409,22 @@ class FlexibleAppVersionNetwork(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             name: str,
+             name: Optional[str] = None,
              forwarded_ports: Optional[Sequence[str]] = None,
              instance_tag: Optional[str] = None,
              session_affinity: Optional[bool] = None,
              subnetwork: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if name is None:
+            raise TypeError("Missing 'name' argument")
+        if forwarded_ports is None and 'forwardedPorts' in kwargs:
+            forwarded_ports = kwargs['forwardedPorts']
+        if instance_tag is None and 'instanceTag' in kwargs:
+            instance_tag = kwargs['instanceTag']
+        if session_affinity is None and 'sessionAffinity' in kwargs:
+            session_affinity = kwargs['sessionAffinity']
+
         _setter("name", name)
         if forwarded_ports is not None:
             _setter("forwarded_ports", forwarded_ports)
@@ -2318,14 +2536,26 @@ class FlexibleAppVersionReadinessCheck(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             path: str,
+             path: Optional[str] = None,
              app_start_timeout: Optional[str] = None,
              check_interval: Optional[str] = None,
              failure_threshold: Optional[float] = None,
              host: Optional[str] = None,
              success_threshold: Optional[float] = None,
              timeout: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if path is None:
+            raise TypeError("Missing 'path' argument")
+        if app_start_timeout is None and 'appStartTimeout' in kwargs:
+            app_start_timeout = kwargs['appStartTimeout']
+        if check_interval is None and 'checkInterval' in kwargs:
+            check_interval = kwargs['checkInterval']
+        if failure_threshold is None and 'failureThreshold' in kwargs:
+            failure_threshold = kwargs['failureThreshold']
+        if success_threshold is None and 'successThreshold' in kwargs:
+            success_threshold = kwargs['successThreshold']
+
         _setter("path", path)
         if app_start_timeout is not None:
             _setter("app_start_timeout", app_start_timeout)
@@ -2445,7 +2675,13 @@ class FlexibleAppVersionResources(dict):
              disk_gb: Optional[int] = None,
              memory_gb: Optional[float] = None,
              volumes: Optional[Sequence['outputs.FlexibleAppVersionResourcesVolume']] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if disk_gb is None and 'diskGb' in kwargs:
+            disk_gb = kwargs['diskGb']
+        if memory_gb is None and 'memoryGb' in kwargs:
+            memory_gb = kwargs['memoryGb']
+
         if cpu is not None:
             _setter("cpu", cpu)
         if disk_gb is not None:
@@ -2528,10 +2764,22 @@ class FlexibleAppVersionResourcesVolume(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             name: str,
-             size_gb: int,
-             volume_type: str,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             name: Optional[str] = None,
+             size_gb: Optional[int] = None,
+             volume_type: Optional[str] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if name is None:
+            raise TypeError("Missing 'name' argument")
+        if size_gb is None and 'sizeGb' in kwargs:
+            size_gb = kwargs['sizeGb']
+        if size_gb is None:
+            raise TypeError("Missing 'size_gb' argument")
+        if volume_type is None and 'volumeType' in kwargs:
+            volume_type = kwargs['volumeType']
+        if volume_type is None:
+            raise TypeError("Missing 'volume_type' argument")
+
         _setter("name", name)
         _setter("size_gb", size_gb)
         _setter("volume_type", volume_type)
@@ -2575,8 +2823,12 @@ class FlexibleAppVersionVpcAccessConnector(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             name: str,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             name: Optional[str] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if name is None:
+            raise TypeError("Missing 'name' argument")
+
         _setter("name", name)
 
     @property
@@ -2624,7 +2876,11 @@ class ServiceNetworkSettingsNetworkSettings(dict):
     def _configure(
              _setter: Callable[[Any, Any], None],
              ingress_traffic_allowed: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if ingress_traffic_allowed is None and 'ingressTrafficAllowed' in kwargs:
+            ingress_traffic_allowed = kwargs['ingressTrafficAllowed']
+
         if ingress_traffic_allowed is not None:
             _setter("ingress_traffic_allowed", ingress_traffic_allowed)
 
@@ -2707,7 +2963,21 @@ class StandardAppVersionAutomaticScaling(dict):
              min_idle_instances: Optional[int] = None,
              min_pending_latency: Optional[str] = None,
              standard_scheduler_settings: Optional['outputs.StandardAppVersionAutomaticScalingStandardSchedulerSettings'] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if max_concurrent_requests is None and 'maxConcurrentRequests' in kwargs:
+            max_concurrent_requests = kwargs['maxConcurrentRequests']
+        if max_idle_instances is None and 'maxIdleInstances' in kwargs:
+            max_idle_instances = kwargs['maxIdleInstances']
+        if max_pending_latency is None and 'maxPendingLatency' in kwargs:
+            max_pending_latency = kwargs['maxPendingLatency']
+        if min_idle_instances is None and 'minIdleInstances' in kwargs:
+            min_idle_instances = kwargs['minIdleInstances']
+        if min_pending_latency is None and 'minPendingLatency' in kwargs:
+            min_pending_latency = kwargs['minPendingLatency']
+        if standard_scheduler_settings is None and 'standardSchedulerSettings' in kwargs:
+            standard_scheduler_settings = kwargs['standardSchedulerSettings']
+
         if max_concurrent_requests is not None:
             _setter("max_concurrent_requests", max_concurrent_requests)
         if max_idle_instances is not None:
@@ -2824,7 +3094,17 @@ class StandardAppVersionAutomaticScalingStandardSchedulerSettings(dict):
              min_instances: Optional[int] = None,
              target_cpu_utilization: Optional[float] = None,
              target_throughput_utilization: Optional[float] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if max_instances is None and 'maxInstances' in kwargs:
+            max_instances = kwargs['maxInstances']
+        if min_instances is None and 'minInstances' in kwargs:
+            min_instances = kwargs['minInstances']
+        if target_cpu_utilization is None and 'targetCpuUtilization' in kwargs:
+            target_cpu_utilization = kwargs['targetCpuUtilization']
+        if target_throughput_utilization is None and 'targetThroughputUtilization' in kwargs:
+            target_throughput_utilization = kwargs['targetThroughputUtilization']
+
         if max_instances is not None:
             _setter("max_instances", max_instances)
         if min_instances is not None:
@@ -2904,9 +3184,17 @@ class StandardAppVersionBasicScaling(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             max_instances: int,
+             max_instances: Optional[int] = None,
              idle_timeout: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if max_instances is None and 'maxInstances' in kwargs:
+            max_instances = kwargs['maxInstances']
+        if max_instances is None:
+            raise TypeError("Missing 'max_instances' argument")
+        if idle_timeout is None and 'idleTimeout' in kwargs:
+            idle_timeout = kwargs['idleTimeout']
+
         _setter("max_instances", max_instances)
         if idle_timeout is not None:
             _setter("idle_timeout", idle_timeout)
@@ -2951,7 +3239,9 @@ class StandardAppVersionDeployment(dict):
              _setter: Callable[[Any, Any], None],
              files: Optional[Sequence['outputs.StandardAppVersionDeploymentFile']] = None,
              zip: Optional['outputs.StandardAppVersionDeploymentZip'] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+
         if files is not None:
             _setter("files", files)
         if zip is not None:
@@ -3016,10 +3306,20 @@ class StandardAppVersionDeploymentFile(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             name: str,
-             source_url: str,
+             name: Optional[str] = None,
+             source_url: Optional[str] = None,
              sha1_sum: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if name is None:
+            raise TypeError("Missing 'name' argument")
+        if source_url is None and 'sourceUrl' in kwargs:
+            source_url = kwargs['sourceUrl']
+        if source_url is None:
+            raise TypeError("Missing 'source_url' argument")
+        if sha1_sum is None and 'sha1Sum' in kwargs:
+            sha1_sum = kwargs['sha1Sum']
+
         _setter("name", name)
         _setter("source_url", source_url)
         if sha1_sum is not None:
@@ -3086,9 +3386,17 @@ class StandardAppVersionDeploymentZip(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             source_url: str,
+             source_url: Optional[str] = None,
              files_count: Optional[int] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if source_url is None and 'sourceUrl' in kwargs:
+            source_url = kwargs['sourceUrl']
+        if source_url is None:
+            raise TypeError("Missing 'source_url' argument")
+        if files_count is None and 'filesCount' in kwargs:
+            files_count = kwargs['filesCount']
+
         _setter("source_url", source_url)
         if files_count is not None:
             _setter("files_count", files_count)
@@ -3126,8 +3434,12 @@ class StandardAppVersionEntrypoint(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             shell: str,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             shell: Optional[str] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if shell is None:
+            raise TypeError("Missing 'shell' argument")
+
         _setter("shell", shell)
 
     @property
@@ -3213,7 +3525,19 @@ class StandardAppVersionHandler(dict):
              security_level: Optional[str] = None,
              static_files: Optional['outputs.StandardAppVersionHandlerStaticFiles'] = None,
              url_regex: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if auth_fail_action is None and 'authFailAction' in kwargs:
+            auth_fail_action = kwargs['authFailAction']
+        if redirect_http_response_code is None and 'redirectHttpResponseCode' in kwargs:
+            redirect_http_response_code = kwargs['redirectHttpResponseCode']
+        if security_level is None and 'securityLevel' in kwargs:
+            security_level = kwargs['securityLevel']
+        if static_files is None and 'staticFiles' in kwargs:
+            static_files = kwargs['staticFiles']
+        if url_regex is None and 'urlRegex' in kwargs:
+            url_regex = kwargs['urlRegex']
+
         if auth_fail_action is not None:
             _setter("auth_fail_action", auth_fail_action)
         if login is not None:
@@ -3325,8 +3649,14 @@ class StandardAppVersionHandlerScript(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             script_path: str,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             script_path: Optional[str] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if script_path is None and 'scriptPath' in kwargs:
+            script_path = kwargs['scriptPath']
+        if script_path is None:
+            raise TypeError("Missing 'script_path' argument")
+
         _setter("script_path", script_path)
 
     @property
@@ -3407,7 +3737,19 @@ class StandardAppVersionHandlerStaticFiles(dict):
              path: Optional[str] = None,
              require_matching_file: Optional[bool] = None,
              upload_path_regex: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if application_readable is None and 'applicationReadable' in kwargs:
+            application_readable = kwargs['applicationReadable']
+        if http_headers is None and 'httpHeaders' in kwargs:
+            http_headers = kwargs['httpHeaders']
+        if mime_type is None and 'mimeType' in kwargs:
+            mime_type = kwargs['mimeType']
+        if require_matching_file is None and 'requireMatchingFile' in kwargs:
+            require_matching_file = kwargs['requireMatchingFile']
+        if upload_path_regex is None and 'uploadPathRegex' in kwargs:
+            upload_path_regex = kwargs['uploadPathRegex']
+
         if application_readable is not None:
             _setter("application_readable", application_readable)
         if expiration is not None:
@@ -3504,7 +3846,9 @@ class StandardAppVersionLibrary(dict):
              _setter: Callable[[Any, Any], None],
              name: Optional[str] = None,
              version: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+
         if name is not None:
             _setter("name", name)
         if version is not None:
@@ -3543,8 +3887,12 @@ class StandardAppVersionManualScaling(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             instances: int,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             instances: Optional[int] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if instances is None:
+            raise TypeError("Missing 'instances' argument")
+
         _setter("instances", instances)
 
     @property
@@ -3592,9 +3940,15 @@ class StandardAppVersionVpcAccessConnector(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             name: str,
+             name: Optional[str] = None,
              egress_setting: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if name is None:
+            raise TypeError("Missing 'name' argument")
+        if egress_setting is None and 'egressSetting' in kwargs:
+            egress_setting = kwargs['egressSetting']
+
         _setter("name", name)
         if egress_setting is not None:
             _setter("egress_setting", egress_setting)