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

pulumi_gcp/storage/outputs.py

@@ -81,8 +81,12 @@ class BucketAutoclass(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             enabled: bool,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             enabled: Optional[bool] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if enabled is None:
+            raise TypeError("Missing 'enabled' argument")
+
         _setter("enabled", enabled)
 
     @property
@@ -140,7 +144,13 @@ class BucketCor(dict):
              methods: Optional[Sequence[str]] = None,
              origins: Optional[Sequence[str]] = None,
              response_headers: Optional[Sequence[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if max_age_seconds is None and 'maxAgeSeconds' in kwargs:
+            max_age_seconds = kwargs['maxAgeSeconds']
+        if response_headers is None and 'responseHeaders' in kwargs:
+            response_headers = kwargs['responseHeaders']
+
         if max_age_seconds is not None:
             _setter("max_age_seconds", max_age_seconds)
         if methods is not None:
@@ -214,8 +224,14 @@ class BucketCustomPlacementConfig(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             data_locations: Sequence[str],
-             opts: Optional[pulumi.ResourceOptions]=None):
+             data_locations: Optional[Sequence[str]] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if data_locations is None and 'dataLocations' in kwargs:
+            data_locations = kwargs['dataLocations']
+        if data_locations is None:
+            raise TypeError("Missing 'data_locations' argument")
+
         _setter("data_locations", data_locations)
 
     @property
@@ -271,8 +287,14 @@ class BucketEncryption(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             default_kms_key_name: str,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             default_kms_key_name: Optional[str] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if default_kms_key_name is None and 'defaultKmsKeyName' in kwargs:
+            default_kms_key_name = kwargs['defaultKmsKeyName']
+        if default_kms_key_name is None:
+            raise TypeError("Missing 'default_kms_key_name' argument")
+
         _setter("default_kms_key_name", default_kms_key_name)
 
     @property
@@ -321,10 +343,16 @@ class BucketIAMBindingCondition(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             expression: str,
-             title: str,
+             expression: Optional[str] = None,
+             title: Optional[str] = None,
              description: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if expression is None:
+            raise TypeError("Missing 'expression' argument")
+        if title is None:
+            raise TypeError("Missing 'title' argument")
+
         _setter("expression", expression)
         _setter("title", title)
         if description is not None:
@@ -383,10 +411,16 @@ class BucketIAMMemberCondition(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             expression: str,
-             title: str,
+             expression: Optional[str] = None,
+             title: Optional[str] = None,
              description: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if expression is None:
+            raise TypeError("Missing 'expression' argument")
+        if title is None:
+            raise TypeError("Missing 'title' argument")
+
         _setter("expression", expression)
         _setter("title", title)
         if description is not None:
@@ -438,9 +472,15 @@ class BucketLifecycleRule(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             action: 'outputs.BucketLifecycleRuleAction',
-             condition: 'outputs.BucketLifecycleRuleCondition',
-             opts: Optional[pulumi.ResourceOptions]=None):
+             action: Optional['outputs.BucketLifecycleRuleAction'] = None,
+             condition: Optional['outputs.BucketLifecycleRuleCondition'] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if action is None:
+            raise TypeError("Missing 'action' argument")
+        if condition is None:
+            raise TypeError("Missing 'condition' argument")
+
         _setter("action", action)
         _setter("condition", condition)
 
@@ -495,9 +535,15 @@ class BucketLifecycleRuleAction(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             type: str,
+             type: Optional[str] = None,
              storage_class: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if type is None:
+            raise TypeError("Missing 'type' argument")
+        if storage_class is None and 'storageClass' in kwargs:
+            storage_class = kwargs['storageClass']
+
         _setter("type", type)
         if storage_class is not None:
             _setter("storage_class", storage_class)
@@ -609,7 +655,29 @@ class BucketLifecycleRuleCondition(dict):
              noncurrent_time_before: Optional[str] = None,
              num_newer_versions: Optional[int] = None,
              with_state: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if created_before is None and 'createdBefore' in kwargs:
+            created_before = kwargs['createdBefore']
+        if custom_time_before is None and 'customTimeBefore' in kwargs:
+            custom_time_before = kwargs['customTimeBefore']
+        if days_since_custom_time is None and 'daysSinceCustomTime' in kwargs:
+            days_since_custom_time = kwargs['daysSinceCustomTime']
+        if days_since_noncurrent_time is None and 'daysSinceNoncurrentTime' in kwargs:
+            days_since_noncurrent_time = kwargs['daysSinceNoncurrentTime']
+        if matches_prefixes is None and 'matchesPrefixes' in kwargs:
+            matches_prefixes = kwargs['matchesPrefixes']
+        if matches_storage_classes is None and 'matchesStorageClasses' in kwargs:
+            matches_storage_classes = kwargs['matchesStorageClasses']
+        if matches_suffixes is None and 'matchesSuffixes' in kwargs:
+            matches_suffixes = kwargs['matchesSuffixes']
+        if noncurrent_time_before is None and 'noncurrentTimeBefore' in kwargs:
+            noncurrent_time_before = kwargs['noncurrentTimeBefore']
+        if num_newer_versions is None and 'numNewerVersions' in kwargs:
+            num_newer_versions = kwargs['numNewerVersions']
+        if with_state is None and 'withState' in kwargs:
+            with_state = kwargs['withState']
+
         if age is not None:
             _setter("age", age)
         if created_before is not None:
@@ -759,9 +827,17 @@ class BucketLogging(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             log_bucket: str,
+             log_bucket: Optional[str] = None,
              log_object_prefix: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if log_bucket is None and 'logBucket' in kwargs:
+            log_bucket = kwargs['logBucket']
+        if log_bucket is None:
+            raise TypeError("Missing 'log_bucket' argument")
+        if log_object_prefix is None and 'logObjectPrefix' in kwargs:
+            log_object_prefix = kwargs['logObjectPrefix']
+
         _setter("log_bucket", log_bucket)
         if log_object_prefix is not None:
             _setter("log_object_prefix", log_object_prefix)
@@ -820,9 +896,17 @@ class BucketObjectCustomerEncryption(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             encryption_key: str,
+             encryption_key: Optional[str] = None,
              encryption_algorithm: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if encryption_key is None and 'encryptionKey' in kwargs:
+            encryption_key = kwargs['encryptionKey']
+        if encryption_key is None:
+            raise TypeError("Missing 'encryption_key' argument")
+        if encryption_algorithm is None and 'encryptionAlgorithm' in kwargs:
+            encryption_algorithm = kwargs['encryptionAlgorithm']
+
         _setter("encryption_key", encryption_key)
         if encryption_algorithm is not None:
             _setter("encryption_algorithm", encryption_algorithm)
@@ -880,9 +964,17 @@ class BucketRetentionPolicy(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             retention_period: int,
+             retention_period: Optional[int] = None,
              is_locked: Optional[bool] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if retention_period is None and 'retentionPeriod' in kwargs:
+            retention_period = kwargs['retentionPeriod']
+        if retention_period is None:
+            raise TypeError("Missing 'retention_period' argument")
+        if is_locked is None and 'isLocked' in kwargs:
+            is_locked = kwargs['isLocked']
+
         _setter("retention_period", retention_period)
         if is_locked is not None:
             _setter("is_locked", is_locked)
@@ -918,8 +1010,12 @@ class BucketVersioning(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             enabled: bool,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             enabled: Optional[bool] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if enabled is None:
+            raise TypeError("Missing 'enabled' argument")
+
         _setter("enabled", enabled)
 
     @property
@@ -971,7 +1067,13 @@ class BucketWebsite(dict):
              _setter: Callable[[Any, Any], None],
              main_page_suffix: Optional[str] = None,
              not_found_page: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if main_page_suffix is None and 'mainPageSuffix' in kwargs:
+            main_page_suffix = kwargs['mainPageSuffix']
+        if not_found_page is None and 'notFoundPage' in kwargs:
+            not_found_page = kwargs['notFoundPage']
+
         if main_page_suffix is not None:
             _setter("main_page_suffix", main_page_suffix)
         if not_found_page is not None:
@@ -1033,7 +1135,11 @@ class DefaultObjectAccessControlProjectTeam(dict):
              _setter: Callable[[Any, Any], None],
              project_number: Optional[str] = None,
              team: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if project_number is None and 'projectNumber' in kwargs:
+            project_number = kwargs['projectNumber']
+
         if project_number is not None:
             _setter("project_number", project_number)
         if team is not None:
@@ -1101,7 +1207,13 @@ class InsightsReportConfigCsvOptions(dict):
              delimiter: Optional[str] = None,
              header_required: Optional[bool] = None,
              record_separator: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if header_required is None and 'headerRequired' in kwargs:
+            header_required = kwargs['headerRequired']
+        if record_separator is None and 'recordSeparator' in kwargs:
+            record_separator = kwargs['recordSeparator']
+
         if delimiter is not None:
             _setter("delimiter", delimiter)
         if header_required is not None:
@@ -1178,10 +1290,22 @@ class InsightsReportConfigFrequencyOptions(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             end_date: 'outputs.InsightsReportConfigFrequencyOptionsEndDate',
-             frequency: str,
-             start_date: 'outputs.InsightsReportConfigFrequencyOptionsStartDate',
-             opts: Optional[pulumi.ResourceOptions]=None):
+             end_date: Optional['outputs.InsightsReportConfigFrequencyOptionsEndDate'] = None,
+             frequency: Optional[str] = None,
+             start_date: Optional['outputs.InsightsReportConfigFrequencyOptionsStartDate'] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if end_date is None and 'endDate' in kwargs:
+            end_date = kwargs['endDate']
+        if end_date is None:
+            raise TypeError("Missing 'end_date' argument")
+        if frequency is None:
+            raise TypeError("Missing 'frequency' argument")
+        if start_date is None and 'startDate' in kwargs:
+            start_date = kwargs['startDate']
+        if start_date is None:
+            raise TypeError("Missing 'start_date' argument")
+
         _setter("end_date", end_date)
         _setter("frequency", frequency)
         _setter("start_date", start_date)
@@ -1234,10 +1358,18 @@ class InsightsReportConfigFrequencyOptionsEndDate(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             day: int,
-             month: int,
-             year: int,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             day: Optional[int] = None,
+             month: Optional[int] = None,
+             year: Optional[int] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if day is None:
+            raise TypeError("Missing 'day' argument")
+        if month is None:
+            raise TypeError("Missing 'month' argument")
+        if year is None:
+            raise TypeError("Missing 'year' argument")
+
         _setter("day", day)
         _setter("month", month)
         _setter("year", year)
@@ -1287,10 +1419,18 @@ class InsightsReportConfigFrequencyOptionsStartDate(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             day: int,
-             month: int,
-             year: int,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             day: Optional[int] = None,
+             month: Optional[int] = None,
+             year: Optional[int] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if day is None:
+            raise TypeError("Missing 'day' argument")
+        if month is None:
+            raise TypeError("Missing 'month' argument")
+        if year is None:
+            raise TypeError("Missing 'year' argument")
+
         _setter("day", day)
         _setter("month", month)
         _setter("year", year)
@@ -1363,10 +1503,22 @@ class InsightsReportConfigObjectMetadataReportOptions(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             metadata_fields: Sequence[str],
-             storage_destination_options: 'outputs.InsightsReportConfigObjectMetadataReportOptionsStorageDestinationOptions',
+             metadata_fields: Optional[Sequence[str]] = None,
+             storage_destination_options: Optional['outputs.InsightsReportConfigObjectMetadataReportOptionsStorageDestinationOptions'] = None,
              storage_filters: Optional['outputs.InsightsReportConfigObjectMetadataReportOptionsStorageFilters'] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if metadata_fields is None and 'metadataFields' in kwargs:
+            metadata_fields = kwargs['metadataFields']
+        if metadata_fields is None:
+            raise TypeError("Missing 'metadata_fields' argument")
+        if storage_destination_options is None and 'storageDestinationOptions' in kwargs:
+            storage_destination_options = kwargs['storageDestinationOptions']
+        if storage_destination_options is None:
+            raise TypeError("Missing 'storage_destination_options' argument")
+        if storage_filters is None and 'storageFilters' in kwargs:
+            storage_filters = kwargs['storageFilters']
+
         _setter("metadata_fields", metadata_fields)
         _setter("storage_destination_options", storage_destination_options)
         if storage_filters is not None:
@@ -1433,9 +1585,15 @@ class InsightsReportConfigObjectMetadataReportOptionsStorageDestinationOptions(d
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             bucket: str,
+             bucket: Optional[str] = None,
              destination_path: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if bucket is None:
+            raise TypeError("Missing 'bucket' argument")
+        if destination_path is None and 'destinationPath' in kwargs:
+            destination_path = kwargs['destinationPath']
+
         _setter("bucket", bucket)
         if destination_path is not None:
             _setter("destination_path", destination_path)
@@ -1472,7 +1630,9 @@ class InsightsReportConfigObjectMetadataReportOptionsStorageFilters(dict):
     def _configure(
              _setter: Callable[[Any, Any], None],
              bucket: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+
         if bucket is not None:
             _setter("bucket", bucket)
 
@@ -1522,7 +1682,11 @@ class ObjectAccessControlProjectTeam(dict):
              _setter: Callable[[Any, Any], None],
              project_number: Optional[str] = None,
              team: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if project_number is None and 'projectNumber' in kwargs:
+            project_number = kwargs['projectNumber']
+
         if project_number is not None:
             _setter("project_number", project_number)
         if team is not None:
@@ -1577,8 +1741,14 @@ class TransferAgentPoolBandwidthLimit(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             limit_mbps: str,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             limit_mbps: Optional[str] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if limit_mbps is None and 'limitMbps' in kwargs:
+            limit_mbps = kwargs['limitMbps']
+        if limit_mbps is None:
+            raise TypeError("Missing 'limit_mbps' argument")
+
         _setter("limit_mbps", limit_mbps)
 
     @property
@@ -1631,10 +1801,22 @@ class TransferJobNotificationConfig(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             payload_format: str,
-             pubsub_topic: str,
+             payload_format: Optional[str] = None,
+             pubsub_topic: Optional[str] = None,
              event_types: Optional[Sequence[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if payload_format is None and 'payloadFormat' in kwargs:
+            payload_format = kwargs['payloadFormat']
+        if payload_format is None:
+            raise TypeError("Missing 'payload_format' argument")
+        if pubsub_topic is None and 'pubsubTopic' in kwargs:
+            pubsub_topic = kwargs['pubsubTopic']
+        if pubsub_topic is None:
+            raise TypeError("Missing 'pubsub_topic' argument")
+        if event_types is None and 'eventTypes' in kwargs:
+            event_types = kwargs['eventTypes']
+
         _setter("payload_format", payload_format)
         _setter("pubsub_topic", pubsub_topic)
         if event_types is not None:
@@ -1711,11 +1893,23 @@ class TransferJobSchedule(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             schedule_start_date: 'outputs.TransferJobScheduleScheduleStartDate',
+             schedule_start_date: Optional['outputs.TransferJobScheduleScheduleStartDate'] = None,
              repeat_interval: Optional[str] = None,
              schedule_end_date: Optional['outputs.TransferJobScheduleScheduleEndDate'] = None,
              start_time_of_day: Optional['outputs.TransferJobScheduleStartTimeOfDay'] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if schedule_start_date is None and 'scheduleStartDate' in kwargs:
+            schedule_start_date = kwargs['scheduleStartDate']
+        if schedule_start_date is None:
+            raise TypeError("Missing 'schedule_start_date' argument")
+        if repeat_interval is None and 'repeatInterval' in kwargs:
+            repeat_interval = kwargs['repeatInterval']
+        if schedule_end_date is None and 'scheduleEndDate' in kwargs:
+            schedule_end_date = kwargs['scheduleEndDate']
+        if start_time_of_day is None and 'startTimeOfDay' in kwargs:
+            start_time_of_day = kwargs['startTimeOfDay']
+
         _setter("schedule_start_date", schedule_start_date)
         if repeat_interval is not None:
             _setter("repeat_interval", repeat_interval)
@@ -1779,10 +1973,18 @@ class TransferJobScheduleScheduleEndDate(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             day: int,
-             month: int,
-             year: int,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             day: Optional[int] = None,
+             month: Optional[int] = None,
+             year: Optional[int] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if day is None:
+            raise TypeError("Missing 'day' argument")
+        if month is None:
+            raise TypeError("Missing 'month' argument")
+        if year is None:
+            raise TypeError("Missing 'year' argument")
+
         _setter("day", day)
         _setter("month", month)
         _setter("year", year)
@@ -1836,10 +2038,18 @@ class TransferJobScheduleScheduleStartDate(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             day: int,
-             month: int,
-             year: int,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             day: Optional[int] = None,
+             month: Optional[int] = None,
+             year: Optional[int] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if day is None:
+            raise TypeError("Missing 'day' argument")
+        if month is None:
+            raise TypeError("Missing 'month' argument")
+        if year is None:
+            raise TypeError("Missing 'year' argument")
+
         _setter("day", day)
         _setter("month", month)
         _setter("year", year)
@@ -1894,11 +2104,21 @@ class TransferJobScheduleStartTimeOfDay(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             hours: int,
-             minutes: int,
-             nanos: int,
-             seconds: int,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             hours: Optional[int] = None,
+             minutes: Optional[int] = None,
+             nanos: Optional[int] = None,
+             seconds: Optional[int] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if hours is None:
+            raise TypeError("Missing 'hours' argument")
+        if minutes is None:
+            raise TypeError("Missing 'minutes' argument")
+        if nanos is None:
+            raise TypeError("Missing 'nanos' argument")
+        if seconds is None:
+            raise TypeError("Missing 'seconds' argument")
+
         _setter("hours", hours)
         _setter("minutes", minutes)
         _setter("nanos", nanos)
@@ -2029,7 +2249,31 @@ class TransferJobTransferSpec(dict):
              sink_agent_pool_name: Optional[str] = None,
              source_agent_pool_name: Optional[str] = None,
              transfer_options: Optional['outputs.TransferJobTransferSpecTransferOptions'] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if aws_s3_data_source is None and 'awsS3DataSource' in kwargs:
+            aws_s3_data_source = kwargs['awsS3DataSource']
+        if azure_blob_storage_data_source is None and 'azureBlobStorageDataSource' in kwargs:
+            azure_blob_storage_data_source = kwargs['azureBlobStorageDataSource']
+        if gcs_data_sink is None and 'gcsDataSink' in kwargs:
+            gcs_data_sink = kwargs['gcsDataSink']
+        if gcs_data_source is None and 'gcsDataSource' in kwargs:
+            gcs_data_source = kwargs['gcsDataSource']
+        if http_data_source is None and 'httpDataSource' in kwargs:
+            http_data_source = kwargs['httpDataSource']
+        if object_conditions is None and 'objectConditions' in kwargs:
+            object_conditions = kwargs['objectConditions']
+        if posix_data_sink is None and 'posixDataSink' in kwargs:
+            posix_data_sink = kwargs['posixDataSink']
+        if posix_data_source is None and 'posixDataSource' in kwargs:
+            posix_data_source = kwargs['posixDataSource']
+        if sink_agent_pool_name is None and 'sinkAgentPoolName' in kwargs:
+            sink_agent_pool_name = kwargs['sinkAgentPoolName']
+        if source_agent_pool_name is None and 'sourceAgentPoolName' in kwargs:
+            source_agent_pool_name = kwargs['sourceAgentPoolName']
+        if transfer_options is None and 'transferOptions' in kwargs:
+            transfer_options = kwargs['transferOptions']
+
         if aws_s3_data_source is not None:
             _setter("aws_s3_data_source", aws_s3_data_source)
         if azure_blob_storage_data_source is not None:
@@ -2186,11 +2430,21 @@ class TransferJobTransferSpecAwsS3DataSource(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             bucket_name: str,
+             bucket_name: Optional[str] = None,
              aws_access_key: Optional['outputs.TransferJobTransferSpecAwsS3DataSourceAwsAccessKey'] = None,
              path: Optional[str] = None,
              role_arn: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if bucket_name is None and 'bucketName' in kwargs:
+            bucket_name = kwargs['bucketName']
+        if bucket_name is None:
+            raise TypeError("Missing 'bucket_name' argument")
+        if aws_access_key is None and 'awsAccessKey' in kwargs:
+            aws_access_key = kwargs['awsAccessKey']
+        if role_arn is None and 'roleArn' in kwargs:
+            role_arn = kwargs['roleArn']
+
         _setter("bucket_name", bucket_name)
         if aws_access_key is not None:
             _setter("aws_access_key", aws_access_key)
@@ -2268,9 +2522,19 @@ class TransferJobTransferSpecAwsS3DataSourceAwsAccessKey(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             access_key_id: str,
-             secret_access_key: str,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             access_key_id: Optional[str] = None,
+             secret_access_key: Optional[str] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if access_key_id is None and 'accessKeyId' in kwargs:
+            access_key_id = kwargs['accessKeyId']
+        if access_key_id is None:
+            raise TypeError("Missing 'access_key_id' argument")
+        if secret_access_key is None and 'secretAccessKey' in kwargs:
+            secret_access_key = kwargs['secretAccessKey']
+        if secret_access_key is None:
+            raise TypeError("Missing 'secret_access_key' argument")
+
         _setter("access_key_id", access_key_id)
         _setter("secret_access_key", secret_access_key)
 
@@ -2333,11 +2597,23 @@ class TransferJobTransferSpecAzureBlobStorageDataSource(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             azure_credentials: 'outputs.TransferJobTransferSpecAzureBlobStorageDataSourceAzureCredentials',
-             container: str,
-             storage_account: str,
+             azure_credentials: Optional['outputs.TransferJobTransferSpecAzureBlobStorageDataSourceAzureCredentials'] = None,
+             container: Optional[str] = None,
+             storage_account: Optional[str] = None,
              path: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if azure_credentials is None and 'azureCredentials' in kwargs:
+            azure_credentials = kwargs['azureCredentials']
+        if azure_credentials is None:
+            raise TypeError("Missing 'azure_credentials' argument")
+        if container is None:
+            raise TypeError("Missing 'container' argument")
+        if storage_account is None and 'storageAccount' in kwargs:
+            storage_account = kwargs['storageAccount']
+        if storage_account is None:
+            raise TypeError("Missing 'storage_account' argument")
+
         _setter("azure_credentials", azure_credentials)
         _setter("container", container)
         _setter("storage_account", storage_account)
@@ -2410,8 +2686,14 @@ class TransferJobTransferSpecAzureBlobStorageDataSourceAzureCredentials(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             sas_token: str,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             sas_token: Optional[str] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if sas_token is None and 'sasToken' in kwargs:
+            sas_token = kwargs['sasToken']
+        if sas_token is None:
+            raise TypeError("Missing 'sas_token' argument")
+
         _setter("sas_token", sas_token)
 
     @property
@@ -2459,9 +2741,15 @@ class TransferJobTransferSpecGcsDataSink(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             bucket_name: str,
+             bucket_name: Optional[str] = None,
              path: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if bucket_name is None and 'bucketName' in kwargs:
+            bucket_name = kwargs['bucketName']
+        if bucket_name is None:
+            raise TypeError("Missing 'bucket_name' argument")
+
         _setter("bucket_name", bucket_name)
         if path is not None:
             _setter("path", path)
@@ -2517,9 +2805,15 @@ class TransferJobTransferSpecGcsDataSource(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             bucket_name: str,
+             bucket_name: Optional[str] = None,
              path: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if bucket_name is None and 'bucketName' in kwargs:
+            bucket_name = kwargs['bucketName']
+        if bucket_name is None:
+            raise TypeError("Missing 'bucket_name' argument")
+
         _setter("bucket_name", bucket_name)
         if path is not None:
             _setter("path", path)
@@ -2572,8 +2866,14 @@ class TransferJobTransferSpecHttpDataSource(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             list_url: str,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             list_url: Optional[str] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if list_url is None and 'listUrl' in kwargs:
+            list_url = kwargs['listUrl']
+        if list_url is None:
+            raise TypeError("Missing 'list_url' argument")
+
         _setter("list_url", list_url)
 
     @property
@@ -2647,7 +2947,21 @@ class TransferJobTransferSpecObjectConditions(dict):
              last_modified_since: Optional[str] = None,
              max_time_elapsed_since_last_modification: Optional[str] = None,
              min_time_elapsed_since_last_modification: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if exclude_prefixes is None and 'excludePrefixes' in kwargs:
+            exclude_prefixes = kwargs['excludePrefixes']
+        if include_prefixes is None and 'includePrefixes' in kwargs:
+            include_prefixes = kwargs['includePrefixes']
+        if last_modified_before is None and 'lastModifiedBefore' in kwargs:
+            last_modified_before = kwargs['lastModifiedBefore']
+        if last_modified_since is None and 'lastModifiedSince' in kwargs:
+            last_modified_since = kwargs['lastModifiedSince']
+        if max_time_elapsed_since_last_modification is None and 'maxTimeElapsedSinceLastModification' in kwargs:
+            max_time_elapsed_since_last_modification = kwargs['maxTimeElapsedSinceLastModification']
+        if min_time_elapsed_since_last_modification is None and 'minTimeElapsedSinceLastModification' in kwargs:
+            min_time_elapsed_since_last_modification = kwargs['minTimeElapsedSinceLastModification']
+
         if exclude_prefixes is not None:
             _setter("exclude_prefixes", exclude_prefixes)
         if include_prefixes is not None:
@@ -2741,8 +3055,14 @@ class TransferJobTransferSpecPosixDataSink(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             root_directory: str,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             root_directory: Optional[str] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if root_directory is None and 'rootDirectory' in kwargs:
+            root_directory = kwargs['rootDirectory']
+        if root_directory is None:
+            raise TypeError("Missing 'root_directory' argument")
+
         _setter("root_directory", root_directory)
 
     @property
@@ -2787,8 +3107,14 @@ class TransferJobTransferSpecPosixDataSource(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             root_directory: str,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             root_directory: Optional[str] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if root_directory is None and 'rootDirectory' in kwargs:
+            root_directory = kwargs['rootDirectory']
+        if root_directory is None:
+            raise TypeError("Missing 'root_directory' argument")
+
         _setter("root_directory", root_directory)
 
     @property
@@ -2853,7 +3179,17 @@ class TransferJobTransferSpecTransferOptions(dict):
              delete_objects_unique_in_sink: Optional[bool] = None,
              overwrite_objects_already_existing_in_sink: Optional[bool] = None,
              overwrite_when: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if delete_objects_from_source_after_transfer is None and 'deleteObjectsFromSourceAfterTransfer' in kwargs:
+            delete_objects_from_source_after_transfer = kwargs['deleteObjectsFromSourceAfterTransfer']
+        if delete_objects_unique_in_sink is None and 'deleteObjectsUniqueInSink' in kwargs:
+            delete_objects_unique_in_sink = kwargs['deleteObjectsUniqueInSink']
+        if overwrite_objects_already_existing_in_sink is None and 'overwriteObjectsAlreadyExistingInSink' in kwargs:
+            overwrite_objects_already_existing_in_sink = kwargs['overwriteObjectsAlreadyExistingInSink']
+        if overwrite_when is None and 'overwriteWhen' in kwargs:
+            overwrite_when = kwargs['overwriteWhen']
+
         if delete_objects_from_source_after_transfer is not None:
             _setter("delete_objects_from_source_after_transfer", delete_objects_from_source_after_transfer)
         if delete_objects_unique_in_sink is not None:
@@ -2908,8 +3244,12 @@ class GetBucketAutoclassResult(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             enabled: bool,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             enabled: Optional[bool] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if enabled is None:
+            raise TypeError("Missing 'enabled' argument")
+
         _setter("enabled", enabled)
 
     @property
@@ -2935,11 +3275,25 @@ class GetBucketCorResult(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             max_age_seconds: int,
-             methods: Sequence[str],
-             origins: Sequence[str],
-             response_headers: Sequence[str],
-             opts: Optional[pulumi.ResourceOptions]=None):
+             max_age_seconds: Optional[int] = None,
+             methods: Optional[Sequence[str]] = None,
+             origins: Optional[Sequence[str]] = None,
+             response_headers: Optional[Sequence[str]] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if max_age_seconds is None and 'maxAgeSeconds' in kwargs:
+            max_age_seconds = kwargs['maxAgeSeconds']
+        if max_age_seconds is None:
+            raise TypeError("Missing 'max_age_seconds' argument")
+        if methods is None:
+            raise TypeError("Missing 'methods' argument")
+        if origins is None:
+            raise TypeError("Missing 'origins' argument")
+        if response_headers is None and 'responseHeaders' in kwargs:
+            response_headers = kwargs['responseHeaders']
+        if response_headers is None:
+            raise TypeError("Missing 'response_headers' argument")
+
         _setter("max_age_seconds", max_age_seconds)
         _setter("methods", methods)
         _setter("origins", origins)
@@ -2977,8 +3331,14 @@ class GetBucketCustomPlacementConfigResult(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             data_locations: Sequence[str],
-             opts: Optional[pulumi.ResourceOptions]=None):
+             data_locations: Optional[Sequence[str]] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if data_locations is None and 'dataLocations' in kwargs:
+            data_locations = kwargs['dataLocations']
+        if data_locations is None:
+            raise TypeError("Missing 'data_locations' argument")
+
         _setter("data_locations", data_locations)
 
     @property
@@ -2998,8 +3358,14 @@ class GetBucketEncryptionResult(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             default_kms_key_name: str,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             default_kms_key_name: Optional[str] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if default_kms_key_name is None and 'defaultKmsKeyName' in kwargs:
+            default_kms_key_name = kwargs['defaultKmsKeyName']
+        if default_kms_key_name is None:
+            raise TypeError("Missing 'default_kms_key_name' argument")
+
         _setter("default_kms_key_name", default_kms_key_name)
 
     @property
@@ -3021,9 +3387,15 @@ class GetBucketLifecycleRuleResult(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             actions: Sequence['outputs.GetBucketLifecycleRuleActionResult'],
-             conditions: Sequence['outputs.GetBucketLifecycleRuleConditionResult'],
-             opts: Optional[pulumi.ResourceOptions]=None):
+             actions: Optional[Sequence['outputs.GetBucketLifecycleRuleActionResult']] = None,
+             conditions: Optional[Sequence['outputs.GetBucketLifecycleRuleConditionResult']] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if actions is None:
+            raise TypeError("Missing 'actions' argument")
+        if conditions is None:
+            raise TypeError("Missing 'conditions' argument")
+
         _setter("actions", actions)
         _setter("conditions", conditions)
 
@@ -3051,9 +3423,17 @@ class GetBucketLifecycleRuleActionResult(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             storage_class: str,
-             type: str,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             storage_class: Optional[str] = None,
+             type: Optional[str] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if storage_class is None and 'storageClass' in kwargs:
+            storage_class = kwargs['storageClass']
+        if storage_class is None:
+            raise TypeError("Missing 'storage_class' argument")
+        if type is None:
+            raise TypeError("Missing 'type' argument")
+
         _setter("storage_class", storage_class)
         _setter("type", type)
 
@@ -3099,18 +3479,62 @@ class GetBucketLifecycleRuleConditionResult(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             age: int,
-             created_before: str,
-             custom_time_before: str,
-             days_since_custom_time: int,
-             days_since_noncurrent_time: int,
-             matches_prefixes: Sequence[str],
-             matches_storage_classes: Sequence[str],
-             matches_suffixes: Sequence[str],
-             noncurrent_time_before: str,
-             num_newer_versions: int,
-             with_state: str,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             age: Optional[int] = None,
+             created_before: Optional[str] = None,
+             custom_time_before: Optional[str] = None,
+             days_since_custom_time: Optional[int] = None,
+             days_since_noncurrent_time: Optional[int] = None,
+             matches_prefixes: Optional[Sequence[str]] = None,
+             matches_storage_classes: Optional[Sequence[str]] = None,
+             matches_suffixes: Optional[Sequence[str]] = None,
+             noncurrent_time_before: Optional[str] = None,
+             num_newer_versions: Optional[int] = None,
+             with_state: Optional[str] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if age is None:
+            raise TypeError("Missing 'age' argument")
+        if created_before is None and 'createdBefore' in kwargs:
+            created_before = kwargs['createdBefore']
+        if created_before is None:
+            raise TypeError("Missing 'created_before' argument")
+        if custom_time_before is None and 'customTimeBefore' in kwargs:
+            custom_time_before = kwargs['customTimeBefore']
+        if custom_time_before is None:
+            raise TypeError("Missing 'custom_time_before' argument")
+        if days_since_custom_time is None and 'daysSinceCustomTime' in kwargs:
+            days_since_custom_time = kwargs['daysSinceCustomTime']
+        if days_since_custom_time is None:
+            raise TypeError("Missing 'days_since_custom_time' argument")
+        if days_since_noncurrent_time is None and 'daysSinceNoncurrentTime' in kwargs:
+            days_since_noncurrent_time = kwargs['daysSinceNoncurrentTime']
+        if days_since_noncurrent_time is None:
+            raise TypeError("Missing 'days_since_noncurrent_time' argument")
+        if matches_prefixes is None and 'matchesPrefixes' in kwargs:
+            matches_prefixes = kwargs['matchesPrefixes']
+        if matches_prefixes is None:
+            raise TypeError("Missing 'matches_prefixes' argument")
+        if matches_storage_classes is None and 'matchesStorageClasses' in kwargs:
+            matches_storage_classes = kwargs['matchesStorageClasses']
+        if matches_storage_classes is None:
+            raise TypeError("Missing 'matches_storage_classes' argument")
+        if matches_suffixes is None and 'matchesSuffixes' in kwargs:
+            matches_suffixes = kwargs['matchesSuffixes']
+        if matches_suffixes is None:
+            raise TypeError("Missing 'matches_suffixes' argument")
+        if noncurrent_time_before is None and 'noncurrentTimeBefore' in kwargs:
+            noncurrent_time_before = kwargs['noncurrentTimeBefore']
+        if noncurrent_time_before is None:
+            raise TypeError("Missing 'noncurrent_time_before' argument")
+        if num_newer_versions is None and 'numNewerVersions' in kwargs:
+            num_newer_versions = kwargs['numNewerVersions']
+        if num_newer_versions is None:
+            raise TypeError("Missing 'num_newer_versions' argument")
+        if with_state is None and 'withState' in kwargs:
+            with_state = kwargs['withState']
+        if with_state is None:
+            raise TypeError("Missing 'with_state' argument")
+
         _setter("age", age)
         _setter("created_before", created_before)
         _setter("custom_time_before", custom_time_before)
@@ -3192,9 +3616,19 @@ class GetBucketLoggingResult(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             log_bucket: str,
-             log_object_prefix: str,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             log_bucket: Optional[str] = None,
+             log_object_prefix: Optional[str] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if log_bucket is None and 'logBucket' in kwargs:
+            log_bucket = kwargs['logBucket']
+        if log_bucket is None:
+            raise TypeError("Missing 'log_bucket' argument")
+        if log_object_prefix is None and 'logObjectPrefix' in kwargs:
+            log_object_prefix = kwargs['logObjectPrefix']
+        if log_object_prefix is None:
+            raise TypeError("Missing 'log_object_prefix' argument")
+
         _setter("log_bucket", log_bucket)
         _setter("log_object_prefix", log_object_prefix)
 
@@ -3222,9 +3656,19 @@ class GetBucketObjectContentCustomerEncryptionResult(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             encryption_algorithm: str,
-             encryption_key: str,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             encryption_algorithm: Optional[str] = None,
+             encryption_key: Optional[str] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if encryption_algorithm is None and 'encryptionAlgorithm' in kwargs:
+            encryption_algorithm = kwargs['encryptionAlgorithm']
+        if encryption_algorithm is None:
+            raise TypeError("Missing 'encryption_algorithm' argument")
+        if encryption_key is None and 'encryptionKey' in kwargs:
+            encryption_key = kwargs['encryptionKey']
+        if encryption_key is None:
+            raise TypeError("Missing 'encryption_key' argument")
+
         _setter("encryption_algorithm", encryption_algorithm)
         _setter("encryption_key", encryption_key)
 
@@ -3252,9 +3696,19 @@ class GetBucketObjectCustomerEncryptionResult(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             encryption_algorithm: str,
-             encryption_key: str,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             encryption_algorithm: Optional[str] = None,
+             encryption_key: Optional[str] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if encryption_algorithm is None and 'encryptionAlgorithm' in kwargs:
+            encryption_algorithm = kwargs['encryptionAlgorithm']
+        if encryption_algorithm is None:
+            raise TypeError("Missing 'encryption_algorithm' argument")
+        if encryption_key is None and 'encryptionKey' in kwargs:
+            encryption_key = kwargs['encryptionKey']
+        if encryption_key is None:
+            raise TypeError("Missing 'encryption_key' argument")
+
         _setter("encryption_algorithm", encryption_algorithm)
         _setter("encryption_key", encryption_key)
 
@@ -3282,9 +3736,19 @@ class GetBucketRetentionPolicyResult(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             is_locked: bool,
-             retention_period: int,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             is_locked: Optional[bool] = None,
+             retention_period: Optional[int] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if is_locked is None and 'isLocked' in kwargs:
+            is_locked = kwargs['isLocked']
+        if is_locked is None:
+            raise TypeError("Missing 'is_locked' argument")
+        if retention_period is None and 'retentionPeriod' in kwargs:
+            retention_period = kwargs['retentionPeriod']
+        if retention_period is None:
+            raise TypeError("Missing 'retention_period' argument")
+
         _setter("is_locked", is_locked)
         _setter("retention_period", retention_period)
 
@@ -3310,8 +3774,12 @@ class GetBucketVersioningResult(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             enabled: bool,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             enabled: Optional[bool] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if enabled is None:
+            raise TypeError("Missing 'enabled' argument")
+
         _setter("enabled", enabled)
 
     @property
@@ -3333,9 +3801,19 @@ class GetBucketWebsiteResult(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             main_page_suffix: str,
-             not_found_page: str,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             main_page_suffix: Optional[str] = None,
+             not_found_page: Optional[str] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if main_page_suffix is None and 'mainPageSuffix' in kwargs:
+            main_page_suffix = kwargs['mainPageSuffix']
+        if main_page_suffix is None:
+            raise TypeError("Missing 'main_page_suffix' argument")
+        if not_found_page is None and 'notFoundPage' in kwargs:
+            not_found_page = kwargs['notFoundPage']
+        if not_found_page is None:
+            raise TypeError("Missing 'not_found_page' argument")
+
         _setter("main_page_suffix", main_page_suffix)
         _setter("not_found_page", not_found_page)