pulumi-aws-native 1.39.0a1762385303__py3-none-any.whl → 1.39.0a1762580459__py3-none-any.whl

pulumi_aws_native/quicksight/outputs.py

@@ -1149,22 +1149,43 @@ __all__ = [
     'DashboardWordCloudSortConfiguration',
     'DashboardWordCloudVisual',
     'DashboardYAxisOptions',
+    'DataSetAggregateOperation',
+    'DataSetAggregation',
+    'DataSetAppendOperation',
+    'DataSetAppendedColumn',
     'DataSetCalculatedColumn',
     'DataSetCastColumnTypeOperation',
+    'DataSetCastColumnTypesOperation',
     'DataSetColumnDescription',
     'DataSetColumnGroup',
+    'DataSetColumnIdMapping',
     'DataSetColumnLevelPermissionRule',
     'DataSetColumnTag',
+    'DataSetColumnToUnpivot',
     'DataSetCreateColumnsOperation',
     'DataSetCustomSql',
+    'DataSetDataPrepAggregationFunction',
+    'DataSetDataPrepConfiguration',
+    'DataSetDataPrepListAggregationFunction',
+    'DataSetDataPrepPercentileAggregationFunction',
+    'DataSetDataPrepSimpleAggregationFunction',
     'DataSetDatasetParameter',
+    'DataSetDateComparisonFilterCondition',
+    'DataSetDateFilterCondition',
+    'DataSetDateFilterValue',
+    'DataSetDateRangeFilterCondition',
     'DataSetDateTimeDatasetParameter',
     'DataSetDateTimeDatasetParameterDefaultValues',
     'DataSetDecimalDatasetParameter',
     'DataSetDecimalDatasetParameterDefaultValues',
+    'DataSetDestinationTable',
+    'DataSetDestinationTableSource',
     'DataSetFieldFolder',
     'DataSetFilterOperation',
+    'DataSetFiltersOperation',
     'DataSetGeoSpatialColumnGroup',
+    'DataSetImportTableOperation',
+    'DataSetImportTableOperationSource',
     'DataSetIncrementalRefresh',
     'DataSetIngestionWaitPolicy',
     'DataSetInputColumn',
@@ -1172,14 +1193,25 @@ __all__ = [
     'DataSetIntegerDatasetParameterDefaultValues',
     'DataSetJoinInstruction',
     'DataSetJoinKeyProperties',
+    'DataSetJoinOperandProperties',
+    'DataSetJoinOperation',
     'DataSetLogicalTable',
     'DataSetLogicalTableSource',
     'DataSetLookbackWindow',
     'DataSetNewDefaultValues',
+    'DataSetNumericComparisonFilterCondition',
+    'DataSetNumericFilterCondition',
+    'DataSetNumericFilterValue',
+    'DataSetNumericRangeFilterCondition',
     'DataSetOutputColumn',
+    'DataSetOutputColumnNameOverride',
     'DataSetOverrideDatasetParameterOperation',
+    'DataSetParentDataSet',
     'DataSetPerformanceConfiguration',
     'DataSetPhysicalTable',
+    'DataSetPivotConfiguration',
+    'DataSetPivotOperation',
+    'DataSetPivotedLabel',
     'DataSetProjectOperation',
     'DataSetRefreshConfiguration',
     'DataSetRefreshFailureConfiguration',
@@ -1187,19 +1219,35 @@ __all__ = [
     'DataSetRefreshProperties',
     'DataSetRelationalTable',
     'DataSetRenameColumnOperation',
+    'DataSetRenameColumnsOperation',
     'DataSetResourcePermission',
+    'DataSetRowLevelPermissionConfiguration',
     'DataSetRowLevelPermissionDataSet',
     'DataSetRowLevelPermissionTagConfiguration',
     'DataSetRowLevelPermissionTagRule',
     'DataSetS3Source',
+    'DataSetSaaSTable',
+    'DataSetSemanticModelConfiguration',
+    'DataSetSemanticTable',
+    'DataSetSourceTable',
+    'DataSetStringComparisonFilterCondition',
     'DataSetStringDatasetParameter',
     'DataSetStringDatasetParameterDefaultValues',
+    'DataSetStringFilterCondition',
+    'DataSetStringFilterValue',
+    'DataSetStringListFilterCondition',
+    'DataSetStringListFilterValue',
+    'DataSetTablePathElement',
     'DataSetTagColumnOperation',
     'DataSetTransformOperation',
+    'DataSetTransformOperationSource',
+    'DataSetTransformStep',
     'DataSetUniqueKey',
+    'DataSetUnpivotOperation',
     'DataSetUntagColumnOperation',
     'DataSetUploadSettings',
     'DataSetUsageConfiguration',
+    'DataSetValueColumnConfiguration',
     'DataSourceAmazonElasticsearchParameters',
     'DataSourceAmazonOpenSearchParameters',
     'DataSourceAthenaParameters',
@@ -74953,6 +75001,198 @@ class DashboardYAxisOptions(dict):
         return pulumi.get(self, "y_axis")
 
 
+@pulumi.output_type
+class DataSetAggregateOperation(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "groupByColumnNames":
+            suggest = "group_by_column_names"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetAggregateOperation. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetAggregateOperation.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetAggregateOperation.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 aggregations: Sequence['outputs.DataSetAggregation'],
+                 alias: _builtins.str,
+                 source: 'outputs.DataSetTransformOperationSource',
+                 group_by_column_names: Optional[Sequence[_builtins.str]] = None):
+        pulumi.set(__self__, "aggregations", aggregations)
+        pulumi.set(__self__, "alias", alias)
+        pulumi.set(__self__, "source", source)
+        if group_by_column_names is not None:
+            pulumi.set(__self__, "group_by_column_names", group_by_column_names)
+
+    @_builtins.property
+    @pulumi.getter
+    def aggregations(self) -> Sequence['outputs.DataSetAggregation']:
+        return pulumi.get(self, "aggregations")
+
+    @_builtins.property
+    @pulumi.getter
+    def alias(self) -> _builtins.str:
+        return pulumi.get(self, "alias")
+
+    @_builtins.property
+    @pulumi.getter
+    def source(self) -> 'outputs.DataSetTransformOperationSource':
+        return pulumi.get(self, "source")
+
+    @_builtins.property
+    @pulumi.getter(name="groupByColumnNames")
+    def group_by_column_names(self) -> Optional[Sequence[_builtins.str]]:
+        return pulumi.get(self, "group_by_column_names")
+
+
+@pulumi.output_type
+class DataSetAggregation(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "aggregationFunction":
+            suggest = "aggregation_function"
+        elif key == "newColumnId":
+            suggest = "new_column_id"
+        elif key == "newColumnName":
+            suggest = "new_column_name"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetAggregation. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetAggregation.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetAggregation.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 aggregation_function: 'outputs.DataSetDataPrepAggregationFunction',
+                 new_column_id: _builtins.str,
+                 new_column_name: _builtins.str):
+        pulumi.set(__self__, "aggregation_function", aggregation_function)
+        pulumi.set(__self__, "new_column_id", new_column_id)
+        pulumi.set(__self__, "new_column_name", new_column_name)
+
+    @_builtins.property
+    @pulumi.getter(name="aggregationFunction")
+    def aggregation_function(self) -> 'outputs.DataSetDataPrepAggregationFunction':
+        return pulumi.get(self, "aggregation_function")
+
+    @_builtins.property
+    @pulumi.getter(name="newColumnId")
+    def new_column_id(self) -> _builtins.str:
+        return pulumi.get(self, "new_column_id")
+
+    @_builtins.property
+    @pulumi.getter(name="newColumnName")
+    def new_column_name(self) -> _builtins.str:
+        return pulumi.get(self, "new_column_name")
+
+
+@pulumi.output_type
+class DataSetAppendOperation(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "appendedColumns":
+            suggest = "appended_columns"
+        elif key == "firstSource":
+            suggest = "first_source"
+        elif key == "secondSource":
+            suggest = "second_source"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetAppendOperation. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetAppendOperation.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetAppendOperation.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 alias: _builtins.str,
+                 appended_columns: Sequence['outputs.DataSetAppendedColumn'],
+                 first_source: Optional['outputs.DataSetTransformOperationSource'] = None,
+                 second_source: Optional['outputs.DataSetTransformOperationSource'] = None):
+        pulumi.set(__self__, "alias", alias)
+        pulumi.set(__self__, "appended_columns", appended_columns)
+        if first_source is not None:
+            pulumi.set(__self__, "first_source", first_source)
+        if second_source is not None:
+            pulumi.set(__self__, "second_source", second_source)
+
+    @_builtins.property
+    @pulumi.getter
+    def alias(self) -> _builtins.str:
+        return pulumi.get(self, "alias")
+
+    @_builtins.property
+    @pulumi.getter(name="appendedColumns")
+    def appended_columns(self) -> Sequence['outputs.DataSetAppendedColumn']:
+        return pulumi.get(self, "appended_columns")
+
+    @_builtins.property
+    @pulumi.getter(name="firstSource")
+    def first_source(self) -> Optional['outputs.DataSetTransformOperationSource']:
+        return pulumi.get(self, "first_source")
+
+    @_builtins.property
+    @pulumi.getter(name="secondSource")
+    def second_source(self) -> Optional['outputs.DataSetTransformOperationSource']:
+        return pulumi.get(self, "second_source")
+
+
+@pulumi.output_type
+class DataSetAppendedColumn(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "columnName":
+            suggest = "column_name"
+        elif key == "newColumnId":
+            suggest = "new_column_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetAppendedColumn. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetAppendedColumn.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetAppendedColumn.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 column_name: _builtins.str,
+                 new_column_id: _builtins.str):
+        pulumi.set(__self__, "column_name", column_name)
+        pulumi.set(__self__, "new_column_id", new_column_id)
+
+    @_builtins.property
+    @pulumi.getter(name="columnName")
+    def column_name(self) -> _builtins.str:
+        return pulumi.get(self, "column_name")
+
+    @_builtins.property
+    @pulumi.getter(name="newColumnId")
+    def new_column_id(self) -> _builtins.str:
+        return pulumi.get(self, "new_column_id")
+
+
 @pulumi.output_type
 class DataSetCalculatedColumn(dict):
     """
@@ -75028,10 +75268,10 @@ class DataSetCastColumnTypeOperation(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "newColumnType":
-            suggest = "new_column_type"
-        elif key == "columnName":
+        if key == "columnName":
             suggest = "column_name"
+        elif key == "newColumnType":
+            suggest = "new_column_type"
         elif key == "subType":
             suggest = "sub_type"
 
@@ -75047,41 +75287,40 @@ class DataSetCastColumnTypeOperation(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
+                 column_name: _builtins.str,
                  new_column_type: 'DataSetColumnDataType',
-                 column_name: Optional[_builtins.str] = None,
                  format: Optional[_builtins.str] = None,
                  sub_type: Optional['DataSetColumnDataSubType'] = None):
         """
         <p>A transform operation that casts a column to a different type.</p>
-        :param 'DataSetColumnDataType' new_column_type: New column data type.
         :param _builtins.str column_name: <p>Column name.</p>
+        :param 'DataSetColumnDataType' new_column_type: New column data type.
         :param _builtins.str format: <p>When casting a column from string to datetime type, you can supply a string in a
                            format supported by Amazon QuickSight to denote the source data format.</p>
         :param 'DataSetColumnDataSubType' sub_type: The sub data type of the new column. Sub types are only available for decimal columns that are part of a SPICE dataset.
         """
+        pulumi.set(__self__, "column_name", column_name)
         pulumi.set(__self__, "new_column_type", new_column_type)
-        if column_name is not None:
-            pulumi.set(__self__, "column_name", column_name)
         if format is not None:
             pulumi.set(__self__, "format", format)
         if sub_type is not None:
             pulumi.set(__self__, "sub_type", sub_type)
 
     @_builtins.property
-    @pulumi.getter(name="newColumnType")
-    def new_column_type(self) -> 'DataSetColumnDataType':
+    @pulumi.getter(name="columnName")
+    def column_name(self) -> _builtins.str:
         """
-        New column data type.
+        <p>Column name.</p>
         """
-        return pulumi.get(self, "new_column_type")
+        return pulumi.get(self, "column_name")
 
     @_builtins.property
-    @pulumi.getter(name="columnName")
-    def column_name(self) -> Optional[_builtins.str]:
+    @pulumi.getter(name="newColumnType")
+    def new_column_type(self) -> 'DataSetColumnDataType':
         """
-        <p>Column name.</p>
+        New column data type.
         """
-        return pulumi.get(self, "column_name")
+        return pulumi.get(self, "new_column_type")
 
     @_builtins.property
     @pulumi.getter
@@ -75101,6 +75340,49 @@ class DataSetCastColumnTypeOperation(dict):
         return pulumi.get(self, "sub_type")
 
 
+@pulumi.output_type
+class DataSetCastColumnTypesOperation(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "castColumnTypeOperations":
+            suggest = "cast_column_type_operations"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetCastColumnTypesOperation. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetCastColumnTypesOperation.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetCastColumnTypesOperation.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 alias: _builtins.str,
+                 cast_column_type_operations: Sequence['outputs.DataSetCastColumnTypeOperation'],
+                 source: 'outputs.DataSetTransformOperationSource'):
+        pulumi.set(__self__, "alias", alias)
+        pulumi.set(__self__, "cast_column_type_operations", cast_column_type_operations)
+        pulumi.set(__self__, "source", source)
+
+    @_builtins.property
+    @pulumi.getter
+    def alias(self) -> _builtins.str:
+        return pulumi.get(self, "alias")
+
+    @_builtins.property
+    @pulumi.getter(name="castColumnTypeOperations")
+    def cast_column_type_operations(self) -> Sequence['outputs.DataSetCastColumnTypeOperation']:
+        return pulumi.get(self, "cast_column_type_operations")
+
+    @_builtins.property
+    @pulumi.getter
+    def source(self) -> 'outputs.DataSetTransformOperationSource':
+        return pulumi.get(self, "source")
+
+
 @pulumi.output_type
 class DataSetColumnDescription(dict):
     """
@@ -75168,6 +75450,44 @@ class DataSetColumnGroup(dict):
         return pulumi.get(self, "geo_spatial_column_group")
 
 
+@pulumi.output_type
+class DataSetColumnIdMapping(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "sourceColumnId":
+            suggest = "source_column_id"
+        elif key == "targetColumnId":
+            suggest = "target_column_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetColumnIdMapping. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetColumnIdMapping.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetColumnIdMapping.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 source_column_id: _builtins.str,
+                 target_column_id: _builtins.str):
+        pulumi.set(__self__, "source_column_id", source_column_id)
+        pulumi.set(__self__, "target_column_id", target_column_id)
+
+    @_builtins.property
+    @pulumi.getter(name="sourceColumnId")
+    def source_column_id(self) -> _builtins.str:
+        return pulumi.get(self, "source_column_id")
+
+    @_builtins.property
+    @pulumi.getter(name="targetColumnId")
+    def target_column_id(self) -> _builtins.str:
+        return pulumi.get(self, "target_column_id")
+
+
 @pulumi.output_type
 class DataSetColumnLevelPermissionRule(dict):
     """
@@ -75296,6 +75616,46 @@ class DataSetColumnTag(dict):
         return pulumi.get(self, "column_geographic_role")
 
 
+@pulumi.output_type
+class DataSetColumnToUnpivot(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "columnName":
+            suggest = "column_name"
+        elif key == "newValue":
+            suggest = "new_value"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetColumnToUnpivot. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetColumnToUnpivot.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetColumnToUnpivot.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 column_name: Optional[_builtins.str] = None,
+                 new_value: Optional[_builtins.str] = None):
+        if column_name is not None:
+            pulumi.set(__self__, "column_name", column_name)
+        if new_value is not None:
+            pulumi.set(__self__, "new_value", new_value)
+
+    @_builtins.property
+    @pulumi.getter(name="columnName")
+    def column_name(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "column_name")
+
+    @_builtins.property
+    @pulumi.getter(name="newValue")
+    def new_value(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "new_value")
+
+
 @pulumi.output_type
 class DataSetCreateColumnsOperation(dict):
     """
@@ -75303,23 +75663,38 @@ class DataSetCreateColumnsOperation(dict):
                 operation form a lexical closure.</p>
     """
     def __init__(__self__, *,
-                 columns: Optional[Sequence['outputs.DataSetCalculatedColumn']] = None):
+                 columns: Sequence['outputs.DataSetCalculatedColumn'],
+                 alias: Optional[_builtins.str] = None,
+                 source: Optional['outputs.DataSetTransformOperationSource'] = None):
         """
         <p>A transform operation that creates calculated columns. Columns created in one such
                     operation form a lexical closure.</p>
         :param Sequence['DataSetCalculatedColumn'] columns: <p>Calculated columns to create.</p>
         """
-        if columns is not None:
-            pulumi.set(__self__, "columns", columns)
+        pulumi.set(__self__, "columns", columns)
+        if alias is not None:
+            pulumi.set(__self__, "alias", alias)
+        if source is not None:
+            pulumi.set(__self__, "source", source)
 
     @_builtins.property
     @pulumi.getter
-    def columns(self) -> Optional[Sequence['outputs.DataSetCalculatedColumn']]:
+    def columns(self) -> Sequence['outputs.DataSetCalculatedColumn']:
         """
         <p>Calculated columns to create.</p>
         """
         return pulumi.get(self, "columns")
 
+    @_builtins.property
+    @pulumi.getter
+    def alias(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "alias")
+
+    @_builtins.property
+    @pulumi.getter
+    def source(self) -> Optional['outputs.DataSetTransformOperationSource']:
+        return pulumi.get(self, "source")
+
 
 @pulumi.output_type
 class DataSetCustomSql(dict):
@@ -75346,22 +75721,29 @@ class DataSetCustomSql(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
+                 columns: Sequence['outputs.DataSetInputColumn'],
                  data_source_arn: _builtins.str,
                  name: _builtins.str,
-                 sql_query: _builtins.str,
-                 columns: Optional[Sequence['outputs.DataSetInputColumn']] = None):
+                 sql_query: _builtins.str):
         """
         <p>A physical table type built from the results of the custom SQL query.</p>
+        :param Sequence['DataSetInputColumn'] columns: <p>The column schema from the SQL query result set.</p>
         :param _builtins.str data_source_arn: <p>The Amazon Resource Name (ARN) of the data source.</p>
         :param _builtins.str name: <p>A display name for the SQL query result.</p>
         :param _builtins.str sql_query: <p>The SQL query.</p>
-        :param Sequence['DataSetInputColumn'] columns: <p>The column schema from the SQL query result set.</p>
         """
+        pulumi.set(__self__, "columns", columns)
         pulumi.set(__self__, "data_source_arn", data_source_arn)
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "sql_query", sql_query)
-        if columns is not None:
-            pulumi.set(__self__, "columns", columns)
+
+    @_builtins.property
+    @pulumi.getter
+    def columns(self) -> Sequence['outputs.DataSetInputColumn']:
+        """
+        <p>The column schema from the SQL query result set.</p>
+        """
+        return pulumi.get(self, "columns")
 
     @_builtins.property
     @pulumi.getter(name="dataSourceArn")
@@ -75387,13 +75769,224 @@ class DataSetCustomSql(dict):
         """
         return pulumi.get(self, "sql_query")
 
+
+@pulumi.output_type
+class DataSetDataPrepAggregationFunction(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "listAggregation":
+            suggest = "list_aggregation"
+        elif key == "percentileAggregation":
+            suggest = "percentile_aggregation"
+        elif key == "simpleAggregation":
+            suggest = "simple_aggregation"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetDataPrepAggregationFunction. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetDataPrepAggregationFunction.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetDataPrepAggregationFunction.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 list_aggregation: Optional['outputs.DataSetDataPrepListAggregationFunction'] = None,
+                 percentile_aggregation: Optional['outputs.DataSetDataPrepPercentileAggregationFunction'] = None,
+                 simple_aggregation: Optional['outputs.DataSetDataPrepSimpleAggregationFunction'] = None):
+        if list_aggregation is not None:
+            pulumi.set(__self__, "list_aggregation", list_aggregation)
+        if percentile_aggregation is not None:
+            pulumi.set(__self__, "percentile_aggregation", percentile_aggregation)
+        if simple_aggregation is not None:
+            pulumi.set(__self__, "simple_aggregation", simple_aggregation)
+
+    @_builtins.property
+    @pulumi.getter(name="listAggregation")
+    def list_aggregation(self) -> Optional['outputs.DataSetDataPrepListAggregationFunction']:
+        return pulumi.get(self, "list_aggregation")
+
+    @_builtins.property
+    @pulumi.getter(name="percentileAggregation")
+    def percentile_aggregation(self) -> Optional['outputs.DataSetDataPrepPercentileAggregationFunction']:
+        return pulumi.get(self, "percentile_aggregation")
+
+    @_builtins.property
+    @pulumi.getter(name="simpleAggregation")
+    def simple_aggregation(self) -> Optional['outputs.DataSetDataPrepSimpleAggregationFunction']:
+        return pulumi.get(self, "simple_aggregation")
+
+
+@pulumi.output_type
+class DataSetDataPrepConfiguration(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "destinationTableMap":
+            suggest = "destination_table_map"
+        elif key == "sourceTableMap":
+            suggest = "source_table_map"
+        elif key == "transformStepMap":
+            suggest = "transform_step_map"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetDataPrepConfiguration. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetDataPrepConfiguration.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetDataPrepConfiguration.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 destination_table_map: Mapping[str, 'outputs.DataSetDestinationTable'],
+                 source_table_map: Mapping[str, 'outputs.DataSetSourceTable'],
+                 transform_step_map: Mapping[str, 'outputs.DataSetTransformStep']):
+        pulumi.set(__self__, "destination_table_map", destination_table_map)
+        pulumi.set(__self__, "source_table_map", source_table_map)
+        pulumi.set(__self__, "transform_step_map", transform_step_map)
+
+    @_builtins.property
+    @pulumi.getter(name="destinationTableMap")
+    def destination_table_map(self) -> Mapping[str, 'outputs.DataSetDestinationTable']:
+        return pulumi.get(self, "destination_table_map")
+
+    @_builtins.property
+    @pulumi.getter(name="sourceTableMap")
+    def source_table_map(self) -> Mapping[str, 'outputs.DataSetSourceTable']:
+        return pulumi.get(self, "source_table_map")
+
+    @_builtins.property
+    @pulumi.getter(name="transformStepMap")
+    def transform_step_map(self) -> Mapping[str, 'outputs.DataSetTransformStep']:
+        return pulumi.get(self, "transform_step_map")
+
+
+@pulumi.output_type
+class DataSetDataPrepListAggregationFunction(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "inputColumnName":
+            suggest = "input_column_name"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetDataPrepListAggregationFunction. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetDataPrepListAggregationFunction.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetDataPrepListAggregationFunction.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 distinct: _builtins.bool,
+                 separator: _builtins.str,
+                 input_column_name: Optional[_builtins.str] = None):
+        pulumi.set(__self__, "distinct", distinct)
+        pulumi.set(__self__, "separator", separator)
+        if input_column_name is not None:
+            pulumi.set(__self__, "input_column_name", input_column_name)
+
     @_builtins.property
     @pulumi.getter
-    def columns(self) -> Optional[Sequence['outputs.DataSetInputColumn']]:
-        """
-        <p>The column schema from the SQL query result set.</p>
-        """
-        return pulumi.get(self, "columns")
+    def distinct(self) -> _builtins.bool:
+        return pulumi.get(self, "distinct")
+
+    @_builtins.property
+    @pulumi.getter
+    def separator(self) -> _builtins.str:
+        return pulumi.get(self, "separator")
+
+    @_builtins.property
+    @pulumi.getter(name="inputColumnName")
+    def input_column_name(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "input_column_name")
+
+
+@pulumi.output_type
+class DataSetDataPrepPercentileAggregationFunction(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "percentileValue":
+            suggest = "percentile_value"
+        elif key == "inputColumnName":
+            suggest = "input_column_name"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetDataPrepPercentileAggregationFunction. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetDataPrepPercentileAggregationFunction.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetDataPrepPercentileAggregationFunction.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 percentile_value: _builtins.float,
+                 input_column_name: Optional[_builtins.str] = None):
+        pulumi.set(__self__, "percentile_value", percentile_value)
+        if input_column_name is not None:
+            pulumi.set(__self__, "input_column_name", input_column_name)
+
+    @_builtins.property
+    @pulumi.getter(name="percentileValue")
+    def percentile_value(self) -> _builtins.float:
+        return pulumi.get(self, "percentile_value")
+
+    @_builtins.property
+    @pulumi.getter(name="inputColumnName")
+    def input_column_name(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "input_column_name")
+
+
+@pulumi.output_type
+class DataSetDataPrepSimpleAggregationFunction(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "functionType":
+            suggest = "function_type"
+        elif key == "inputColumnName":
+            suggest = "input_column_name"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetDataPrepSimpleAggregationFunction. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetDataPrepSimpleAggregationFunction.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetDataPrepSimpleAggregationFunction.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 function_type: 'DataSetDataPrepSimpleAggregationFunctionType',
+                 input_column_name: Optional[_builtins.str] = None):
+        pulumi.set(__self__, "function_type", function_type)
+        if input_column_name is not None:
+            pulumi.set(__self__, "input_column_name", input_column_name)
+
+    @_builtins.property
+    @pulumi.getter(name="functionType")
+    def function_type(self) -> 'DataSetDataPrepSimpleAggregationFunctionType':
+        return pulumi.get(self, "function_type")
+
+    @_builtins.property
+    @pulumi.getter(name="inputColumnName")
+    def input_column_name(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "input_column_name")
 
 
 @pulumi.output_type
@@ -75478,6 +76071,166 @@ class DataSetDatasetParameter(dict):
         return pulumi.get(self, "string_dataset_parameter")
 
 
+@pulumi.output_type
+class DataSetDateComparisonFilterCondition(dict):
+    def __init__(__self__, *,
+                 operator: 'DataSetDateComparisonFilterOperator',
+                 value: Optional['outputs.DataSetDateFilterValue'] = None):
+        pulumi.set(__self__, "operator", operator)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def operator(self) -> 'DataSetDateComparisonFilterOperator':
+        return pulumi.get(self, "operator")
+
+    @_builtins.property
+    @pulumi.getter
+    def value(self) -> Optional['outputs.DataSetDateFilterValue']:
+        return pulumi.get(self, "value")
+
+
+@pulumi.output_type
+class DataSetDateFilterCondition(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "columnName":
+            suggest = "column_name"
+        elif key == "comparisonFilterCondition":
+            suggest = "comparison_filter_condition"
+        elif key == "rangeFilterCondition":
+            suggest = "range_filter_condition"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetDateFilterCondition. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetDateFilterCondition.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetDateFilterCondition.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 column_name: Optional[_builtins.str] = None,
+                 comparison_filter_condition: Optional['outputs.DataSetDateComparisonFilterCondition'] = None,
+                 range_filter_condition: Optional['outputs.DataSetDateRangeFilterCondition'] = None):
+        if column_name is not None:
+            pulumi.set(__self__, "column_name", column_name)
+        if comparison_filter_condition is not None:
+            pulumi.set(__self__, "comparison_filter_condition", comparison_filter_condition)
+        if range_filter_condition is not None:
+            pulumi.set(__self__, "range_filter_condition", range_filter_condition)
+
+    @_builtins.property
+    @pulumi.getter(name="columnName")
+    def column_name(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "column_name")
+
+    @_builtins.property
+    @pulumi.getter(name="comparisonFilterCondition")
+    def comparison_filter_condition(self) -> Optional['outputs.DataSetDateComparisonFilterCondition']:
+        return pulumi.get(self, "comparison_filter_condition")
+
+    @_builtins.property
+    @pulumi.getter(name="rangeFilterCondition")
+    def range_filter_condition(self) -> Optional['outputs.DataSetDateRangeFilterCondition']:
+        return pulumi.get(self, "range_filter_condition")
+
+
+@pulumi.output_type
+class DataSetDateFilterValue(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "staticValue":
+            suggest = "static_value"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetDateFilterValue. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetDateFilterValue.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetDateFilterValue.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 static_value: Optional[_builtins.str] = None):
+        if static_value is not None:
+            pulumi.set(__self__, "static_value", static_value)
+
+    @_builtins.property
+    @pulumi.getter(name="staticValue")
+    def static_value(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "static_value")
+
+
+@pulumi.output_type
+class DataSetDateRangeFilterCondition(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "includeMaximum":
+            suggest = "include_maximum"
+        elif key == "includeMinimum":
+            suggest = "include_minimum"
+        elif key == "rangeMaximum":
+            suggest = "range_maximum"
+        elif key == "rangeMinimum":
+            suggest = "range_minimum"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetDateRangeFilterCondition. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetDateRangeFilterCondition.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetDateRangeFilterCondition.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 include_maximum: Optional[_builtins.bool] = None,
+                 include_minimum: Optional[_builtins.bool] = None,
+                 range_maximum: Optional['outputs.DataSetDateFilterValue'] = None,
+                 range_minimum: Optional['outputs.DataSetDateFilterValue'] = None):
+        if include_maximum is not None:
+            pulumi.set(__self__, "include_maximum", include_maximum)
+        if include_minimum is not None:
+            pulumi.set(__self__, "include_minimum", include_minimum)
+        if range_maximum is not None:
+            pulumi.set(__self__, "range_maximum", range_maximum)
+        if range_minimum is not None:
+            pulumi.set(__self__, "range_minimum", range_minimum)
+
+    @_builtins.property
+    @pulumi.getter(name="includeMaximum")
+    def include_maximum(self) -> Optional[_builtins.bool]:
+        return pulumi.get(self, "include_maximum")
+
+    @_builtins.property
+    @pulumi.getter(name="includeMinimum")
+    def include_minimum(self) -> Optional[_builtins.bool]:
+        return pulumi.get(self, "include_minimum")
+
+    @_builtins.property
+    @pulumi.getter(name="rangeMaximum")
+    def range_maximum(self) -> Optional['outputs.DataSetDateFilterValue']:
+        return pulumi.get(self, "range_maximum")
+
+    @_builtins.property
+    @pulumi.getter(name="rangeMinimum")
+    def range_minimum(self) -> Optional['outputs.DataSetDateFilterValue']:
+        return pulumi.get(self, "range_minimum")
+
+
 @pulumi.output_type
 class DataSetDateTimeDatasetParameter(dict):
     """
@@ -75722,6 +76475,54 @@ class DataSetDecimalDatasetParameterDefaultValues(dict):
         return pulumi.get(self, "static_values")
 
 
+@pulumi.output_type
+class DataSetDestinationTable(dict):
+    def __init__(__self__, *,
+                 alias: _builtins.str,
+                 source: 'outputs.DataSetDestinationTableSource'):
+        pulumi.set(__self__, "alias", alias)
+        pulumi.set(__self__, "source", source)
+
+    @_builtins.property
+    @pulumi.getter
+    def alias(self) -> _builtins.str:
+        return pulumi.get(self, "alias")
+
+    @_builtins.property
+    @pulumi.getter
+    def source(self) -> 'outputs.DataSetDestinationTableSource':
+        return pulumi.get(self, "source")
+
+
+@pulumi.output_type
+class DataSetDestinationTableSource(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "transformOperationId":
+            suggest = "transform_operation_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetDestinationTableSource. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetDestinationTableSource.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetDestinationTableSource.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 transform_operation_id: _builtins.str):
+        pulumi.set(__self__, "transform_operation_id", transform_operation_id)
+
+    @_builtins.property
+    @pulumi.getter(name="transformOperationId")
+    def transform_operation_id(self) -> _builtins.str:
+        return pulumi.get(self, "transform_operation_id")
+
+
 @pulumi.output_type
 class DataSetFieldFolder(dict):
     """
@@ -75767,6 +76568,12 @@ class DataSetFilterOperation(dict):
         suggest = None
         if key == "conditionExpression":
             suggest = "condition_expression"
+        elif key == "dateFilterCondition":
+            suggest = "date_filter_condition"
+        elif key == "numericFilterCondition":
+            suggest = "numeric_filter_condition"
+        elif key == "stringFilterCondition":
+            suggest = "string_filter_condition"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in DataSetFilterOperation. Access the value via the '{suggest}' property getter instead.")
@@ -75780,7 +76587,10 @@ class DataSetFilterOperation(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 condition_expression: Optional[_builtins.str] = None):
+                 condition_expression: Optional[_builtins.str] = None,
+                 date_filter_condition: Optional['outputs.DataSetDateFilterCondition'] = None,
+                 numeric_filter_condition: Optional['outputs.DataSetNumericFilterCondition'] = None,
+                 string_filter_condition: Optional['outputs.DataSetStringFilterCondition'] = None):
         """
         <p>A transform operation that filters rows based on a condition.</p>
         :param _builtins.str condition_expression: <p>An expression that must evaluate to a Boolean value. Rows for which the expression
@@ -75788,6 +76598,12 @@ class DataSetFilterOperation(dict):
         """
         if condition_expression is not None:
             pulumi.set(__self__, "condition_expression", condition_expression)
+        if date_filter_condition is not None:
+            pulumi.set(__self__, "date_filter_condition", date_filter_condition)
+        if numeric_filter_condition is not None:
+            pulumi.set(__self__, "numeric_filter_condition", numeric_filter_condition)
+        if string_filter_condition is not None:
+            pulumi.set(__self__, "string_filter_condition", string_filter_condition)
 
     @_builtins.property
     @pulumi.getter(name="conditionExpression")
@@ -75798,6 +76614,64 @@ class DataSetFilterOperation(dict):
         """
         return pulumi.get(self, "condition_expression")
 
+    @_builtins.property
+    @pulumi.getter(name="dateFilterCondition")
+    def date_filter_condition(self) -> Optional['outputs.DataSetDateFilterCondition']:
+        return pulumi.get(self, "date_filter_condition")
+
+    @_builtins.property
+    @pulumi.getter(name="numericFilterCondition")
+    def numeric_filter_condition(self) -> Optional['outputs.DataSetNumericFilterCondition']:
+        return pulumi.get(self, "numeric_filter_condition")
+
+    @_builtins.property
+    @pulumi.getter(name="stringFilterCondition")
+    def string_filter_condition(self) -> Optional['outputs.DataSetStringFilterCondition']:
+        return pulumi.get(self, "string_filter_condition")
+
+
+@pulumi.output_type
+class DataSetFiltersOperation(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "filterOperations":
+            suggest = "filter_operations"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetFiltersOperation. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetFiltersOperation.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetFiltersOperation.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 alias: _builtins.str,
+                 filter_operations: Sequence['outputs.DataSetFilterOperation'],
+                 source: 'outputs.DataSetTransformOperationSource'):
+        pulumi.set(__self__, "alias", alias)
+        pulumi.set(__self__, "filter_operations", filter_operations)
+        pulumi.set(__self__, "source", source)
+
+    @_builtins.property
+    @pulumi.getter
+    def alias(self) -> _builtins.str:
+        return pulumi.get(self, "alias")
+
+    @_builtins.property
+    @pulumi.getter(name="filterOperations")
+    def filter_operations(self) -> Sequence['outputs.DataSetFilterOperation']:
+        return pulumi.get(self, "filter_operations")
+
+    @_builtins.property
+    @pulumi.getter
+    def source(self) -> 'outputs.DataSetTransformOperationSource':
+        return pulumi.get(self, "source")
+
 
 @pulumi.output_type
 class DataSetGeoSpatialColumnGroup(dict):
@@ -75861,6 +76735,64 @@ class DataSetGeoSpatialColumnGroup(dict):
         return pulumi.get(self, "country_code")
 
 
+@pulumi.output_type
+class DataSetImportTableOperation(dict):
+    def __init__(__self__, *,
+                 alias: _builtins.str,
+                 source: 'outputs.DataSetImportTableOperationSource'):
+        pulumi.set(__self__, "alias", alias)
+        pulumi.set(__self__, "source", source)
+
+    @_builtins.property
+    @pulumi.getter
+    def alias(self) -> _builtins.str:
+        return pulumi.get(self, "alias")
+
+    @_builtins.property
+    @pulumi.getter
+    def source(self) -> 'outputs.DataSetImportTableOperationSource':
+        return pulumi.get(self, "source")
+
+
+@pulumi.output_type
+class DataSetImportTableOperationSource(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "sourceTableId":
+            suggest = "source_table_id"
+        elif key == "columnIdMappings":
+            suggest = "column_id_mappings"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetImportTableOperationSource. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetImportTableOperationSource.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetImportTableOperationSource.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 source_table_id: _builtins.str,
+                 column_id_mappings: Optional[Sequence['outputs.DataSetColumnIdMapping']] = None):
+        pulumi.set(__self__, "source_table_id", source_table_id)
+        if column_id_mappings is not None:
+            pulumi.set(__self__, "column_id_mappings", column_id_mappings)
+
+    @_builtins.property
+    @pulumi.getter(name="sourceTableId")
+    def source_table_id(self) -> _builtins.str:
+        return pulumi.get(self, "source_table_id")
+
+    @_builtins.property
+    @pulumi.getter(name="columnIdMappings")
+    def column_id_mappings(self) -> Optional[Sequence['outputs.DataSetColumnIdMapping']]:
+        return pulumi.get(self, "column_id_mappings")
+
+
 @pulumi.output_type
 class DataSetIncrementalRefresh(dict):
     """
@@ -75983,6 +76915,7 @@ class DataSetInputColumn(dict):
     def __init__(__self__, *,
                  name: _builtins.str,
                  type: 'DataSetInputColumnDataType',
+                 id: Optional[_builtins.str] = None,
                  sub_type: Optional['DataSetColumnDataSubType'] = None):
         """
         <p>Metadata for a column that is used as the input of a transform operation.</p>
@@ -75992,6 +76925,8 @@ class DataSetInputColumn(dict):
         """
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "type", type)
+        if id is not None:
+            pulumi.set(__self__, "id", id)
         if sub_type is not None:
             pulumi.set(__self__, "sub_type", sub_type)
 
@@ -76011,6 +76946,11 @@ class DataSetInputColumn(dict):
         """
         return pulumi.get(self, "type")
 
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "id")
+
     @_builtins.property
     @pulumi.getter(name="subType")
     def sub_type(self) -> Optional['DataSetColumnDataSubType']:
@@ -76118,17 +77058,17 @@ class DataSetIntegerDatasetParameterDefaultValues(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 static_values: Optional[Sequence[_builtins.float]] = None):
+                 static_values: Optional[Sequence[_builtins.int]] = None):
         """
         <p>The default values of an integer parameter.</p>
-        :param Sequence[_builtins.float] static_values: <p>A list of static default values for a given integer parameter.</p>
+        :param Sequence[_builtins.int] static_values: <p>A list of static default values for a given integer parameter.</p>
         """
         if static_values is not None:
             pulumi.set(__self__, "static_values", static_values)
 
     @_builtins.property
     @pulumi.getter(name="staticValues")
-    def static_values(self) -> Optional[Sequence[_builtins.float]]:
+    def static_values(self) -> Optional[Sequence[_builtins.int]]:
         """
         <p>A list of static default values for a given integer parameter.</p>
         """
@@ -76281,6 +77221,116 @@ class DataSetJoinKeyProperties(dict):
         return pulumi.get(self, "unique_key")
 
 
+@pulumi.output_type
+class DataSetJoinOperandProperties(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "outputColumnNameOverrides":
+            suggest = "output_column_name_overrides"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetJoinOperandProperties. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetJoinOperandProperties.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetJoinOperandProperties.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 output_column_name_overrides: Sequence['outputs.DataSetOutputColumnNameOverride']):
+        pulumi.set(__self__, "output_column_name_overrides", output_column_name_overrides)
+
+    @_builtins.property
+    @pulumi.getter(name="outputColumnNameOverrides")
+    def output_column_name_overrides(self) -> Sequence['outputs.DataSetOutputColumnNameOverride']:
+        return pulumi.get(self, "output_column_name_overrides")
+
+
+@pulumi.output_type
+class DataSetJoinOperation(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "leftOperand":
+            suggest = "left_operand"
+        elif key == "onClause":
+            suggest = "on_clause"
+        elif key == "rightOperand":
+            suggest = "right_operand"
+        elif key == "leftOperandProperties":
+            suggest = "left_operand_properties"
+        elif key == "rightOperandProperties":
+            suggest = "right_operand_properties"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetJoinOperation. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetJoinOperation.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetJoinOperation.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 alias: _builtins.str,
+                 left_operand: 'outputs.DataSetTransformOperationSource',
+                 on_clause: _builtins.str,
+                 right_operand: 'outputs.DataSetTransformOperationSource',
+                 type: 'DataSetJoinOperationType',
+                 left_operand_properties: Optional['outputs.DataSetJoinOperandProperties'] = None,
+                 right_operand_properties: Optional['outputs.DataSetJoinOperandProperties'] = None):
+        pulumi.set(__self__, "alias", alias)
+        pulumi.set(__self__, "left_operand", left_operand)
+        pulumi.set(__self__, "on_clause", on_clause)
+        pulumi.set(__self__, "right_operand", right_operand)
+        pulumi.set(__self__, "type", type)
+        if left_operand_properties is not None:
+            pulumi.set(__self__, "left_operand_properties", left_operand_properties)
+        if right_operand_properties is not None:
+            pulumi.set(__self__, "right_operand_properties", right_operand_properties)
+
+    @_builtins.property
+    @pulumi.getter
+    def alias(self) -> _builtins.str:
+        return pulumi.get(self, "alias")
+
+    @_builtins.property
+    @pulumi.getter(name="leftOperand")
+    def left_operand(self) -> 'outputs.DataSetTransformOperationSource':
+        return pulumi.get(self, "left_operand")
+
+    @_builtins.property
+    @pulumi.getter(name="onClause")
+    def on_clause(self) -> _builtins.str:
+        return pulumi.get(self, "on_clause")
+
+    @_builtins.property
+    @pulumi.getter(name="rightOperand")
+    def right_operand(self) -> 'outputs.DataSetTransformOperationSource':
+        return pulumi.get(self, "right_operand")
+
+    @_builtins.property
+    @pulumi.getter
+    def type(self) -> 'DataSetJoinOperationType':
+        return pulumi.get(self, "type")
+
+    @_builtins.property
+    @pulumi.getter(name="leftOperandProperties")
+    def left_operand_properties(self) -> Optional['outputs.DataSetJoinOperandProperties']:
+        return pulumi.get(self, "left_operand_properties")
+
+    @_builtins.property
+    @pulumi.getter(name="rightOperandProperties")
+    def right_operand_properties(self) -> Optional['outputs.DataSetJoinOperandProperties']:
+        return pulumi.get(self, "right_operand_properties")
+
+
 @pulumi.output_type
 class DataSetLogicalTable(dict):
     """
@@ -76308,8 +77358,8 @@ class DataSetLogicalTable(dict):
 
     def __init__(__self__, *,
                  alias: _builtins.str,
-                 data_transforms: Optional[Sequence['outputs.DataSetTransformOperation']] = None,
-                 source: Optional['outputs.DataSetLogicalTableSource'] = None):
+                 source: 'outputs.DataSetLogicalTableSource',
+                 data_transforms: Optional[Sequence['outputs.DataSetTransformOperation']] = None):
         """
         <p>A <i>logical table</i> is a unit that joins and that data
                     transformations operate on. A logical table has a source, which can be either a physical
@@ -76317,13 +77367,11 @@ class DataSetLogicalTable(dict):
                     table acts as a mutable copy of that physical table through transform operations.</p>
         :param _builtins.str alias: <p>A display name for the logical table.</p>
         :param Sequence['DataSetTransformOperation'] data_transforms: <p>Transform operations that act on this logical table. For this structure to be valid, only one of the attributes can be non-null. </p>
-        :param 'DataSetLogicalTableSource' source: Source of this logical table.
         """
         pulumi.set(__self__, "alias", alias)
+        pulumi.set(__self__, "source", source)
         if data_transforms is not None:
             pulumi.set(__self__, "data_transforms", data_transforms)
-        if source is not None:
-            pulumi.set(__self__, "source", source)
 
     @_builtins.property
     @pulumi.getter
@@ -76333,6 +77381,11 @@ class DataSetLogicalTable(dict):
         """
         return pulumi.get(self, "alias")
 
+    @_builtins.property
+    @pulumi.getter
+    def source(self) -> 'outputs.DataSetLogicalTableSource':
+        return pulumi.get(self, "source")
+
     @_builtins.property
     @pulumi.getter(name="dataTransforms")
     def data_transforms(self) -> Optional[Sequence['outputs.DataSetTransformOperation']]:
@@ -76341,14 +77394,6 @@ class DataSetLogicalTable(dict):
         """
         return pulumi.get(self, "data_transforms")
 
-    @_builtins.property
-    @pulumi.getter
-    def source(self) -> Optional['outputs.DataSetLogicalTableSource']:
-        """
-        Source of this logical table.
-        """
-        return pulumi.get(self, "source")
-
 
 @pulumi.output_type
 class DataSetLogicalTableSource(dict):
@@ -76514,13 +77559,13 @@ class DataSetNewDefaultValues(dict):
     def __init__(__self__, *,
                  date_time_static_values: Optional[Sequence[_builtins.str]] = None,
                  decimal_static_values: Optional[Sequence[_builtins.float]] = None,
-                 integer_static_values: Optional[Sequence[_builtins.float]] = None,
+                 integer_static_values: Optional[Sequence[_builtins.int]] = None,
                  string_static_values: Optional[Sequence[_builtins.str]] = None):
         """
         <p>The configuration that overrides the existing default values for a dataset parameter that is inherited from another dataset.</p>
         :param Sequence[_builtins.str] date_time_static_values: <p>A list of static default values for a given date time parameter.</p>
         :param Sequence[_builtins.float] decimal_static_values: <p>A list of static default values for a given decimal parameter.</p>
-        :param Sequence[_builtins.float] integer_static_values: <p>A list of static default values for a given integer parameter.</p>
+        :param Sequence[_builtins.int] integer_static_values: <p>A list of static default values for a given integer parameter.</p>
         :param Sequence[_builtins.str] string_static_values: <p>A list of static default values for a given string parameter.</p>
         """
         if date_time_static_values is not None:
@@ -76550,7 +77595,7 @@ class DataSetNewDefaultValues(dict):
 
     @_builtins.property
     @pulumi.getter(name="integerStaticValues")
-    def integer_static_values(self) -> Optional[Sequence[_builtins.float]]:
+    def integer_static_values(self) -> Optional[Sequence[_builtins.int]]:
         """
         <p>A list of static default values for a given integer parameter.</p>
         """
@@ -76565,6 +77610,166 @@ class DataSetNewDefaultValues(dict):
         return pulumi.get(self, "string_static_values")
 
 
+@pulumi.output_type
+class DataSetNumericComparisonFilterCondition(dict):
+    def __init__(__self__, *,
+                 operator: 'DataSetNumericComparisonFilterOperator',
+                 value: Optional['outputs.DataSetNumericFilterValue'] = None):
+        pulumi.set(__self__, "operator", operator)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def operator(self) -> 'DataSetNumericComparisonFilterOperator':
+        return pulumi.get(self, "operator")
+
+    @_builtins.property
+    @pulumi.getter
+    def value(self) -> Optional['outputs.DataSetNumericFilterValue']:
+        return pulumi.get(self, "value")
+
+
+@pulumi.output_type
+class DataSetNumericFilterCondition(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "columnName":
+            suggest = "column_name"
+        elif key == "comparisonFilterCondition":
+            suggest = "comparison_filter_condition"
+        elif key == "rangeFilterCondition":
+            suggest = "range_filter_condition"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetNumericFilterCondition. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetNumericFilterCondition.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetNumericFilterCondition.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 column_name: Optional[_builtins.str] = None,
+                 comparison_filter_condition: Optional['outputs.DataSetNumericComparisonFilterCondition'] = None,
+                 range_filter_condition: Optional['outputs.DataSetNumericRangeFilterCondition'] = None):
+        if column_name is not None:
+            pulumi.set(__self__, "column_name", column_name)
+        if comparison_filter_condition is not None:
+            pulumi.set(__self__, "comparison_filter_condition", comparison_filter_condition)
+        if range_filter_condition is not None:
+            pulumi.set(__self__, "range_filter_condition", range_filter_condition)
+
+    @_builtins.property
+    @pulumi.getter(name="columnName")
+    def column_name(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "column_name")
+
+    @_builtins.property
+    @pulumi.getter(name="comparisonFilterCondition")
+    def comparison_filter_condition(self) -> Optional['outputs.DataSetNumericComparisonFilterCondition']:
+        return pulumi.get(self, "comparison_filter_condition")
+
+    @_builtins.property
+    @pulumi.getter(name="rangeFilterCondition")
+    def range_filter_condition(self) -> Optional['outputs.DataSetNumericRangeFilterCondition']:
+        return pulumi.get(self, "range_filter_condition")
+
+
+@pulumi.output_type
+class DataSetNumericFilterValue(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "staticValue":
+            suggest = "static_value"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetNumericFilterValue. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetNumericFilterValue.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetNumericFilterValue.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 static_value: Optional[_builtins.float] = None):
+        if static_value is not None:
+            pulumi.set(__self__, "static_value", static_value)
+
+    @_builtins.property
+    @pulumi.getter(name="staticValue")
+    def static_value(self) -> Optional[_builtins.float]:
+        return pulumi.get(self, "static_value")
+
+
+@pulumi.output_type
+class DataSetNumericRangeFilterCondition(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "includeMaximum":
+            suggest = "include_maximum"
+        elif key == "includeMinimum":
+            suggest = "include_minimum"
+        elif key == "rangeMaximum":
+            suggest = "range_maximum"
+        elif key == "rangeMinimum":
+            suggest = "range_minimum"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetNumericRangeFilterCondition. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetNumericRangeFilterCondition.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetNumericRangeFilterCondition.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 include_maximum: Optional[_builtins.bool] = None,
+                 include_minimum: Optional[_builtins.bool] = None,
+                 range_maximum: Optional['outputs.DataSetNumericFilterValue'] = None,
+                 range_minimum: Optional['outputs.DataSetNumericFilterValue'] = None):
+        if include_maximum is not None:
+            pulumi.set(__self__, "include_maximum", include_maximum)
+        if include_minimum is not None:
+            pulumi.set(__self__, "include_minimum", include_minimum)
+        if range_maximum is not None:
+            pulumi.set(__self__, "range_maximum", range_maximum)
+        if range_minimum is not None:
+            pulumi.set(__self__, "range_minimum", range_minimum)
+
+    @_builtins.property
+    @pulumi.getter(name="includeMaximum")
+    def include_maximum(self) -> Optional[_builtins.bool]:
+        return pulumi.get(self, "include_maximum")
+
+    @_builtins.property
+    @pulumi.getter(name="includeMinimum")
+    def include_minimum(self) -> Optional[_builtins.bool]:
+        return pulumi.get(self, "include_minimum")
+
+    @_builtins.property
+    @pulumi.getter(name="rangeMaximum")
+    def range_maximum(self) -> Optional['outputs.DataSetNumericFilterValue']:
+        return pulumi.get(self, "range_maximum")
+
+    @_builtins.property
+    @pulumi.getter(name="rangeMinimum")
+    def range_minimum(self) -> Optional['outputs.DataSetNumericFilterValue']:
+        return pulumi.get(self, "range_minimum")
+
+
 @pulumi.output_type
 class DataSetOutputColumn(dict):
     """
@@ -76589,6 +77794,7 @@ class DataSetOutputColumn(dict):
 
     def __init__(__self__, *,
                  description: Optional[_builtins.str] = None,
+                 id: Optional[_builtins.str] = None,
                  name: Optional[_builtins.str] = None,
                  sub_type: Optional['DataSetColumnDataSubType'] = None,
                  type: Optional['DataSetColumnDataType'] = None):
@@ -76601,6 +77807,8 @@ class DataSetOutputColumn(dict):
         """
         if description is not None:
             pulumi.set(__self__, "description", description)
+        if id is not None:
+            pulumi.set(__self__, "id", id)
         if name is not None:
             pulumi.set(__self__, "name", name)
         if sub_type is not None:
@@ -76616,6 +77824,11 @@ class DataSetOutputColumn(dict):
         """
         return pulumi.get(self, "description")
 
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "id")
+
     @_builtins.property
     @pulumi.getter
     def name(self) -> Optional[_builtins.str]:
@@ -76641,6 +77854,45 @@ class DataSetOutputColumn(dict):
         return pulumi.get(self, "type")
 
 
+@pulumi.output_type
+class DataSetOutputColumnNameOverride(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "outputColumnName":
+            suggest = "output_column_name"
+        elif key == "sourceColumnName":
+            suggest = "source_column_name"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetOutputColumnNameOverride. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetOutputColumnNameOverride.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetOutputColumnNameOverride.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 output_column_name: _builtins.str,
+                 source_column_name: Optional[_builtins.str] = None):
+        pulumi.set(__self__, "output_column_name", output_column_name)
+        if source_column_name is not None:
+            pulumi.set(__self__, "source_column_name", source_column_name)
+
+    @_builtins.property
+    @pulumi.getter(name="outputColumnName")
+    def output_column_name(self) -> _builtins.str:
+        return pulumi.get(self, "output_column_name")
+
+    @_builtins.property
+    @pulumi.getter(name="sourceColumnName")
+    def source_column_name(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "source_column_name")
+
+
 @pulumi.output_type
 class DataSetOverrideDatasetParameterOperation(dict):
     """
@@ -76708,6 +77960,44 @@ class DataSetOverrideDatasetParameterOperation(dict):
         return pulumi.get(self, "new_parameter_name")
 
 
+@pulumi.output_type
+class DataSetParentDataSet(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "dataSetArn":
+            suggest = "data_set_arn"
+        elif key == "inputColumns":
+            suggest = "input_columns"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetParentDataSet. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetParentDataSet.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetParentDataSet.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 data_set_arn: _builtins.str,
+                 input_columns: Sequence['outputs.DataSetInputColumn']):
+        pulumi.set(__self__, "data_set_arn", data_set_arn)
+        pulumi.set(__self__, "input_columns", input_columns)
+
+    @_builtins.property
+    @pulumi.getter(name="dataSetArn")
+    def data_set_arn(self) -> _builtins.str:
+        return pulumi.get(self, "data_set_arn")
+
+    @_builtins.property
+    @pulumi.getter(name="inputColumns")
+    def input_columns(self) -> Sequence['outputs.DataSetInputColumn']:
+        return pulumi.get(self, "input_columns")
+
+
 @pulumi.output_type
 class DataSetPerformanceConfiguration(dict):
     @staticmethod
@@ -76754,6 +78044,8 @@ class DataSetPhysicalTable(dict):
             suggest = "relational_table"
         elif key == "s3Source":
             suggest = "s3_source"
+        elif key == "saaSTable":
+            suggest = "saa_s_table"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in DataSetPhysicalTable. Access the value via the '{suggest}' property getter instead.")
@@ -76769,7 +78061,8 @@ class DataSetPhysicalTable(dict):
     def __init__(__self__, *,
                  custom_sql: Optional['outputs.DataSetCustomSql'] = None,
                  relational_table: Optional['outputs.DataSetRelationalTable'] = None,
-                 s3_source: Optional['outputs.DataSetS3Source'] = None):
+                 s3_source: Optional['outputs.DataSetS3Source'] = None,
+                 saa_s_table: Optional['outputs.DataSetSaaSTable'] = None):
         """
         <p>A view of a data source that contains information about the shape of the data in the
                     underlying source. This is a variant type structure. For this structure to be valid,
@@ -76784,6 +78077,8 @@ class DataSetPhysicalTable(dict):
             pulumi.set(__self__, "relational_table", relational_table)
         if s3_source is not None:
             pulumi.set(__self__, "s3_source", s3_source)
+        if saa_s_table is not None:
+            pulumi.set(__self__, "saa_s_table", saa_s_table)
 
     @_builtins.property
     @pulumi.getter(name="customSql")
@@ -76809,6 +78104,159 @@ class DataSetPhysicalTable(dict):
         """
         return pulumi.get(self, "s3_source")
 
+    @_builtins.property
+    @pulumi.getter(name="saaSTable")
+    def saa_s_table(self) -> Optional['outputs.DataSetSaaSTable']:
+        return pulumi.get(self, "saa_s_table")
+
+
+@pulumi.output_type
+class DataSetPivotConfiguration(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "pivotedLabels":
+            suggest = "pivoted_labels"
+        elif key == "labelColumnName":
+            suggest = "label_column_name"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetPivotConfiguration. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetPivotConfiguration.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetPivotConfiguration.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 pivoted_labels: Sequence['outputs.DataSetPivotedLabel'],
+                 label_column_name: Optional[_builtins.str] = None):
+        pulumi.set(__self__, "pivoted_labels", pivoted_labels)
+        if label_column_name is not None:
+            pulumi.set(__self__, "label_column_name", label_column_name)
+
+    @_builtins.property
+    @pulumi.getter(name="pivotedLabels")
+    def pivoted_labels(self) -> Sequence['outputs.DataSetPivotedLabel']:
+        return pulumi.get(self, "pivoted_labels")
+
+    @_builtins.property
+    @pulumi.getter(name="labelColumnName")
+    def label_column_name(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "label_column_name")
+
+
+@pulumi.output_type
+class DataSetPivotOperation(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "pivotConfiguration":
+            suggest = "pivot_configuration"
+        elif key == "valueColumnConfiguration":
+            suggest = "value_column_configuration"
+        elif key == "groupByColumnNames":
+            suggest = "group_by_column_names"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetPivotOperation. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetPivotOperation.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetPivotOperation.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 alias: _builtins.str,
+                 pivot_configuration: 'outputs.DataSetPivotConfiguration',
+                 source: 'outputs.DataSetTransformOperationSource',
+                 value_column_configuration: 'outputs.DataSetValueColumnConfiguration',
+                 group_by_column_names: Optional[Sequence[_builtins.str]] = None):
+        pulumi.set(__self__, "alias", alias)
+        pulumi.set(__self__, "pivot_configuration", pivot_configuration)
+        pulumi.set(__self__, "source", source)
+        pulumi.set(__self__, "value_column_configuration", value_column_configuration)
+        if group_by_column_names is not None:
+            pulumi.set(__self__, "group_by_column_names", group_by_column_names)
+
+    @_builtins.property
+    @pulumi.getter
+    def alias(self) -> _builtins.str:
+        return pulumi.get(self, "alias")
+
+    @_builtins.property
+    @pulumi.getter(name="pivotConfiguration")
+    def pivot_configuration(self) -> 'outputs.DataSetPivotConfiguration':
+        return pulumi.get(self, "pivot_configuration")
+
+    @_builtins.property
+    @pulumi.getter
+    def source(self) -> 'outputs.DataSetTransformOperationSource':
+        return pulumi.get(self, "source")
+
+    @_builtins.property
+    @pulumi.getter(name="valueColumnConfiguration")
+    def value_column_configuration(self) -> 'outputs.DataSetValueColumnConfiguration':
+        return pulumi.get(self, "value_column_configuration")
+
+    @_builtins.property
+    @pulumi.getter(name="groupByColumnNames")
+    def group_by_column_names(self) -> Optional[Sequence[_builtins.str]]:
+        return pulumi.get(self, "group_by_column_names")
+
+
+@pulumi.output_type
+class DataSetPivotedLabel(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "labelName":
+            suggest = "label_name"
+        elif key == "newColumnId":
+            suggest = "new_column_id"
+        elif key == "newColumnName":
+            suggest = "new_column_name"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetPivotedLabel. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetPivotedLabel.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetPivotedLabel.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 label_name: _builtins.str,
+                 new_column_id: _builtins.str,
+                 new_column_name: _builtins.str):
+        pulumi.set(__self__, "label_name", label_name)
+        pulumi.set(__self__, "new_column_id", new_column_id)
+        pulumi.set(__self__, "new_column_name", new_column_name)
+
+    @_builtins.property
+    @pulumi.getter(name="labelName")
+    def label_name(self) -> _builtins.str:
+        return pulumi.get(self, "label_name")
+
+    @_builtins.property
+    @pulumi.getter(name="newColumnId")
+    def new_column_id(self) -> _builtins.str:
+        return pulumi.get(self, "new_column_id")
+
+    @_builtins.property
+    @pulumi.getter(name="newColumnName")
+    def new_column_name(self) -> _builtins.str:
+        return pulumi.get(self, "new_column_name")
+
 
 @pulumi.output_type
 class DataSetProjectOperation(dict):
@@ -76834,14 +78282,25 @@ class DataSetProjectOperation(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 projected_columns: Optional[Sequence[_builtins.str]] = None):
+                 alias: Optional[_builtins.str] = None,
+                 projected_columns: Optional[Sequence[_builtins.str]] = None,
+                 source: Optional['outputs.DataSetTransformOperationSource'] = None):
         """
         <p>A transform operation that projects columns. Operations that come after a projection
                     can only refer to projected columns.</p>
         :param Sequence[_builtins.str] projected_columns: <p>Projected columns.</p>
         """
+        if alias is not None:
+            pulumi.set(__self__, "alias", alias)
         if projected_columns is not None:
             pulumi.set(__self__, "projected_columns", projected_columns)
+        if source is not None:
+            pulumi.set(__self__, "source", source)
+
+    @_builtins.property
+    @pulumi.getter
+    def alias(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "alias")
 
     @_builtins.property
     @pulumi.getter(name="projectedColumns")
@@ -76851,6 +78310,11 @@ class DataSetProjectOperation(dict):
         """
         return pulumi.get(self, "projected_columns")
 
+    @_builtins.property
+    @pulumi.getter
+    def source(self) -> Optional['outputs.DataSetTransformOperationSource']:
+        return pulumi.get(self, "source")
+
 
 @pulumi.output_type
 class DataSetRefreshConfiguration(dict):
@@ -77043,24 +78507,23 @@ class DataSetRelationalTable(dict):
 
     def __init__(__self__, *,
                  data_source_arn: _builtins.str,
+                 input_columns: Sequence['outputs.DataSetInputColumn'],
                  name: _builtins.str,
                  catalog: Optional[_builtins.str] = None,
-                 input_columns: Optional[Sequence['outputs.DataSetInputColumn']] = None,
                  schema: Optional[_builtins.str] = None):
         """
         <p>A physical table type for relational data sources.</p>
         :param _builtins.str data_source_arn: <p>The Amazon Resource Name (ARN) for the data source.</p>
+        :param Sequence['DataSetInputColumn'] input_columns: <p>The column schema of the table.</p>
         :param _builtins.str name: <p>The name of the relational table.</p>
         :param _builtins.str catalog: <p>The catalog associated with a table.</p>
-        :param Sequence['DataSetInputColumn'] input_columns: <p>The column schema of the table.</p>
         :param _builtins.str schema: <p>The schema name. This name applies to certain relational database engines.</p>
         """
         pulumi.set(__self__, "data_source_arn", data_source_arn)
+        pulumi.set(__self__, "input_columns", input_columns)
         pulumi.set(__self__, "name", name)
         if catalog is not None:
             pulumi.set(__self__, "catalog", catalog)
-        if input_columns is not None:
-            pulumi.set(__self__, "input_columns", input_columns)
         if schema is not None:
             pulumi.set(__self__, "schema", schema)
 
@@ -77072,6 +78535,14 @@ class DataSetRelationalTable(dict):
         """
         return pulumi.get(self, "data_source_arn")
 
+    @_builtins.property
+    @pulumi.getter(name="inputColumns")
+    def input_columns(self) -> Sequence['outputs.DataSetInputColumn']:
+        """
+        <p>The column schema of the table.</p>
+        """
+        return pulumi.get(self, "input_columns")
+
     @_builtins.property
     @pulumi.getter
     def name(self) -> _builtins.str:
@@ -77088,14 +78559,6 @@ class DataSetRelationalTable(dict):
         """
         return pulumi.get(self, "catalog")
 
-    @_builtins.property
-    @pulumi.getter(name="inputColumns")
-    def input_columns(self) -> Optional[Sequence['outputs.DataSetInputColumn']]:
-        """
-        <p>The column schema of the table.</p>
-        """
-        return pulumi.get(self, "input_columns")
-
     @_builtins.property
     @pulumi.getter
     def schema(self) -> Optional[_builtins.str]:
@@ -77130,21 +78593,19 @@ class DataSetRenameColumnOperation(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 column_name: Optional[_builtins.str] = None,
-                 new_column_name: Optional[_builtins.str] = None):
+                 column_name: _builtins.str,
+                 new_column_name: _builtins.str):
         """
         <p>A transform operation that renames a column.</p>
         :param _builtins.str column_name: <p>The name of the column to be renamed.</p>
         :param _builtins.str new_column_name: <p>The new name for the column.</p>
         """
-        if column_name is not None:
-            pulumi.set(__self__, "column_name", column_name)
-        if new_column_name is not None:
-            pulumi.set(__self__, "new_column_name", new_column_name)
+        pulumi.set(__self__, "column_name", column_name)
+        pulumi.set(__self__, "new_column_name", new_column_name)
 
     @_builtins.property
     @pulumi.getter(name="columnName")
-    def column_name(self) -> Optional[_builtins.str]:
+    def column_name(self) -> _builtins.str:
         """
         <p>The name of the column to be renamed.</p>
         """
@@ -77152,13 +78613,56 @@ class DataSetRenameColumnOperation(dict):
 
     @_builtins.property
     @pulumi.getter(name="newColumnName")
-    def new_column_name(self) -> Optional[_builtins.str]:
+    def new_column_name(self) -> _builtins.str:
         """
         <p>The new name for the column.</p>
         """
         return pulumi.get(self, "new_column_name")
 
 
+@pulumi.output_type
+class DataSetRenameColumnsOperation(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "renameColumnOperations":
+            suggest = "rename_column_operations"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetRenameColumnsOperation. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetRenameColumnsOperation.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetRenameColumnsOperation.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 alias: _builtins.str,
+                 rename_column_operations: Sequence['outputs.DataSetRenameColumnOperation'],
+                 source: 'outputs.DataSetTransformOperationSource'):
+        pulumi.set(__self__, "alias", alias)
+        pulumi.set(__self__, "rename_column_operations", rename_column_operations)
+        pulumi.set(__self__, "source", source)
+
+    @_builtins.property
+    @pulumi.getter
+    def alias(self) -> _builtins.str:
+        return pulumi.get(self, "alias")
+
+    @_builtins.property
+    @pulumi.getter(name="renameColumnOperations")
+    def rename_column_operations(self) -> Sequence['outputs.DataSetRenameColumnOperation']:
+        return pulumi.get(self, "rename_column_operations")
+
+    @_builtins.property
+    @pulumi.getter
+    def source(self) -> 'outputs.DataSetTransformOperationSource':
+        return pulumi.get(self, "source")
+
+
 @pulumi.output_type
 class DataSetResourcePermission(dict):
     """
@@ -77220,6 +78724,46 @@ class DataSetResourcePermission(dict):
         return pulumi.get(self, "principal")
 
 
+@pulumi.output_type
+class DataSetRowLevelPermissionConfiguration(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "rowLevelPermissionDataSet":
+            suggest = "row_level_permission_data_set"
+        elif key == "tagConfiguration":
+            suggest = "tag_configuration"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetRowLevelPermissionConfiguration. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetRowLevelPermissionConfiguration.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetRowLevelPermissionConfiguration.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 row_level_permission_data_set: Optional['outputs.DataSetRowLevelPermissionDataSet'] = None,
+                 tag_configuration: Optional['outputs.DataSetRowLevelPermissionTagConfiguration'] = None):
+        if row_level_permission_data_set is not None:
+            pulumi.set(__self__, "row_level_permission_data_set", row_level_permission_data_set)
+        if tag_configuration is not None:
+            pulumi.set(__self__, "tag_configuration", tag_configuration)
+
+    @_builtins.property
+    @pulumi.getter(name="rowLevelPermissionDataSet")
+    def row_level_permission_data_set(self) -> Optional['outputs.DataSetRowLevelPermissionDataSet']:
+        return pulumi.get(self, "row_level_permission_data_set")
+
+    @_builtins.property
+    @pulumi.getter(name="tagConfiguration")
+    def tag_configuration(self) -> Optional['outputs.DataSetRowLevelPermissionTagConfiguration']:
+        return pulumi.get(self, "tag_configuration")
+
+
 @pulumi.output_type
 class DataSetRowLevelPermissionDataSet(dict):
     """
@@ -77395,10 +78939,10 @@ class DataSetRowLevelPermissionTagRule(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "tagKey":
-            suggest = "tag_key"
-        elif key == "columnName":
+        if key == "columnName":
             suggest = "column_name"
+        elif key == "tagKey":
+            suggest = "tag_key"
         elif key == "matchAllValue":
             suggest = "match_all_value"
         elif key == "tagMultiValueDelimiter":
@@ -77416,40 +78960,39 @@ class DataSetRowLevelPermissionTagRule(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
+                 column_name: _builtins.str,
                  tag_key: _builtins.str,
-                 column_name: Optional[_builtins.str] = None,
                  match_all_value: Optional[_builtins.str] = None,
                  tag_multi_value_delimiter: Optional[_builtins.str] = None):
         """
         <p>A set of rules associated with a tag.</p>
-        :param _builtins.str tag_key: <p>The unique key for a tag.</p>
         :param _builtins.str column_name: <p>The column name that a tag key is assigned to.</p>
+        :param _builtins.str tag_key: <p>The unique key for a tag.</p>
         :param _builtins.str match_all_value: <p>A string that you want to use to filter by all the values in a column in the dataset and don’t want to list the values one by one. For example, you can use an asterisk as your match all value.</p>
         :param _builtins.str tag_multi_value_delimiter: <p>A string that you want to use to delimit the values when you pass the values at run time. For example, you can delimit the values with a comma.</p>
         """
+        pulumi.set(__self__, "column_name", column_name)
         pulumi.set(__self__, "tag_key", tag_key)
-        if column_name is not None:
-            pulumi.set(__self__, "column_name", column_name)
         if match_all_value is not None:
             pulumi.set(__self__, "match_all_value", match_all_value)
         if tag_multi_value_delimiter is not None:
             pulumi.set(__self__, "tag_multi_value_delimiter", tag_multi_value_delimiter)
 
     @_builtins.property
-    @pulumi.getter(name="tagKey")
-    def tag_key(self) -> _builtins.str:
+    @pulumi.getter(name="columnName")
+    def column_name(self) -> _builtins.str:
         """
-        <p>The unique key for a tag.</p>
+        <p>The column name that a tag key is assigned to.</p>
         """
-        return pulumi.get(self, "tag_key")
+        return pulumi.get(self, "column_name")
 
     @_builtins.property
-    @pulumi.getter(name="columnName")
-    def column_name(self) -> Optional[_builtins.str]:
+    @pulumi.getter(name="tagKey")
+    def tag_key(self) -> _builtins.str:
         """
-        <p>The column name that a tag key is assigned to.</p>
+        <p>The unique key for a tag.</p>
         """
-        return pulumi.get(self, "column_name")
+        return pulumi.get(self, "tag_key")
 
     @_builtins.property
     @pulumi.getter(name="matchAllValue")
@@ -77496,7 +79039,7 @@ class DataSetS3Source(dict):
 
     def __init__(__self__, *,
                  data_source_arn: _builtins.str,
-                 input_columns: Optional[Sequence['outputs.DataSetInputColumn']] = None,
+                 input_columns: Sequence['outputs.DataSetInputColumn'],
                  upload_settings: Optional['outputs.DataSetUploadSettings'] = None):
         """
         <p>A physical table type for an S3 data source.</p>
@@ -77508,8 +79051,7 @@ class DataSetS3Source(dict):
         :param 'DataSetUploadSettings' upload_settings: Information about the format for the S3 source file or files.
         """
         pulumi.set(__self__, "data_source_arn", data_source_arn)
-        if input_columns is not None:
-            pulumi.set(__self__, "input_columns", input_columns)
+        pulumi.set(__self__, "input_columns", input_columns)
         if upload_settings is not None:
             pulumi.set(__self__, "upload_settings", upload_settings)
 
@@ -77523,7 +79065,7 @@ class DataSetS3Source(dict):
 
     @_builtins.property
     @pulumi.getter(name="inputColumns")
-    def input_columns(self) -> Optional[Sequence['outputs.DataSetInputColumn']]:
+    def input_columns(self) -> Sequence['outputs.DataSetInputColumn']:
         """
         <p>A physical table type for an S3 data source.</p>
                  <note>
@@ -77541,6 +79083,189 @@ class DataSetS3Source(dict):
         return pulumi.get(self, "upload_settings")
 
 
+@pulumi.output_type
+class DataSetSaaSTable(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "dataSourceArn":
+            suggest = "data_source_arn"
+        elif key == "inputColumns":
+            suggest = "input_columns"
+        elif key == "tablePath":
+            suggest = "table_path"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetSaaSTable. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetSaaSTable.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetSaaSTable.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 data_source_arn: _builtins.str,
+                 input_columns: Sequence['outputs.DataSetInputColumn'],
+                 table_path: Sequence['outputs.DataSetTablePathElement']):
+        pulumi.set(__self__, "data_source_arn", data_source_arn)
+        pulumi.set(__self__, "input_columns", input_columns)
+        pulumi.set(__self__, "table_path", table_path)
+
+    @_builtins.property
+    @pulumi.getter(name="dataSourceArn")
+    def data_source_arn(self) -> _builtins.str:
+        return pulumi.get(self, "data_source_arn")
+
+    @_builtins.property
+    @pulumi.getter(name="inputColumns")
+    def input_columns(self) -> Sequence['outputs.DataSetInputColumn']:
+        return pulumi.get(self, "input_columns")
+
+    @_builtins.property
+    @pulumi.getter(name="tablePath")
+    def table_path(self) -> Sequence['outputs.DataSetTablePathElement']:
+        return pulumi.get(self, "table_path")
+
+
+@pulumi.output_type
+class DataSetSemanticModelConfiguration(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "tableMap":
+            suggest = "table_map"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetSemanticModelConfiguration. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetSemanticModelConfiguration.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetSemanticModelConfiguration.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 table_map: Optional[Mapping[str, 'outputs.DataSetSemanticTable']] = None):
+        if table_map is not None:
+            pulumi.set(__self__, "table_map", table_map)
+
+    @_builtins.property
+    @pulumi.getter(name="tableMap")
+    def table_map(self) -> Optional[Mapping[str, 'outputs.DataSetSemanticTable']]:
+        return pulumi.get(self, "table_map")
+
+
+@pulumi.output_type
+class DataSetSemanticTable(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "destinationTableId":
+            suggest = "destination_table_id"
+        elif key == "rowLevelPermissionConfiguration":
+            suggest = "row_level_permission_configuration"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetSemanticTable. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetSemanticTable.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetSemanticTable.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 alias: _builtins.str,
+                 destination_table_id: _builtins.str,
+                 row_level_permission_configuration: Optional['outputs.DataSetRowLevelPermissionConfiguration'] = None):
+        pulumi.set(__self__, "alias", alias)
+        pulumi.set(__self__, "destination_table_id", destination_table_id)
+        if row_level_permission_configuration is not None:
+            pulumi.set(__self__, "row_level_permission_configuration", row_level_permission_configuration)
+
+    @_builtins.property
+    @pulumi.getter
+    def alias(self) -> _builtins.str:
+        return pulumi.get(self, "alias")
+
+    @_builtins.property
+    @pulumi.getter(name="destinationTableId")
+    def destination_table_id(self) -> _builtins.str:
+        return pulumi.get(self, "destination_table_id")
+
+    @_builtins.property
+    @pulumi.getter(name="rowLevelPermissionConfiguration")
+    def row_level_permission_configuration(self) -> Optional['outputs.DataSetRowLevelPermissionConfiguration']:
+        return pulumi.get(self, "row_level_permission_configuration")
+
+
+@pulumi.output_type
+class DataSetSourceTable(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "dataSet":
+            suggest = "data_set"
+        elif key == "physicalTableId":
+            suggest = "physical_table_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetSourceTable. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetSourceTable.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetSourceTable.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 data_set: Optional['outputs.DataSetParentDataSet'] = None,
+                 physical_table_id: Optional[_builtins.str] = None):
+        if data_set is not None:
+            pulumi.set(__self__, "data_set", data_set)
+        if physical_table_id is not None:
+            pulumi.set(__self__, "physical_table_id", physical_table_id)
+
+    @_builtins.property
+    @pulumi.getter(name="dataSet")
+    def data_set(self) -> Optional['outputs.DataSetParentDataSet']:
+        return pulumi.get(self, "data_set")
+
+    @_builtins.property
+    @pulumi.getter(name="physicalTableId")
+    def physical_table_id(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "physical_table_id")
+
+
+@pulumi.output_type
+class DataSetStringComparisonFilterCondition(dict):
+    def __init__(__self__, *,
+                 operator: 'DataSetStringComparisonFilterOperator',
+                 value: Optional['outputs.DataSetStringFilterValue'] = None):
+        pulumi.set(__self__, "operator", operator)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def operator(self) -> 'DataSetStringComparisonFilterOperator':
+        return pulumi.get(self, "operator")
+
+    @_builtins.property
+    @pulumi.getter
+    def value(self) -> Optional['outputs.DataSetStringFilterValue']:
+        return pulumi.get(self, "value")
+
+
 @pulumi.output_type
 class DataSetStringDatasetParameter(dict):
     """
@@ -77656,6 +79381,157 @@ class DataSetStringDatasetParameterDefaultValues(dict):
         return pulumi.get(self, "static_values")
 
 
+@pulumi.output_type
+class DataSetStringFilterCondition(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "columnName":
+            suggest = "column_name"
+        elif key == "comparisonFilterCondition":
+            suggest = "comparison_filter_condition"
+        elif key == "listFilterCondition":
+            suggest = "list_filter_condition"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetStringFilterCondition. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetStringFilterCondition.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetStringFilterCondition.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 column_name: Optional[_builtins.str] = None,
+                 comparison_filter_condition: Optional['outputs.DataSetStringComparisonFilterCondition'] = None,
+                 list_filter_condition: Optional['outputs.DataSetStringListFilterCondition'] = None):
+        if column_name is not None:
+            pulumi.set(__self__, "column_name", column_name)
+        if comparison_filter_condition is not None:
+            pulumi.set(__self__, "comparison_filter_condition", comparison_filter_condition)
+        if list_filter_condition is not None:
+            pulumi.set(__self__, "list_filter_condition", list_filter_condition)
+
+    @_builtins.property
+    @pulumi.getter(name="columnName")
+    def column_name(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "column_name")
+
+    @_builtins.property
+    @pulumi.getter(name="comparisonFilterCondition")
+    def comparison_filter_condition(self) -> Optional['outputs.DataSetStringComparisonFilterCondition']:
+        return pulumi.get(self, "comparison_filter_condition")
+
+    @_builtins.property
+    @pulumi.getter(name="listFilterCondition")
+    def list_filter_condition(self) -> Optional['outputs.DataSetStringListFilterCondition']:
+        return pulumi.get(self, "list_filter_condition")
+
+
+@pulumi.output_type
+class DataSetStringFilterValue(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "staticValue":
+            suggest = "static_value"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetStringFilterValue. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetStringFilterValue.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetStringFilterValue.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 static_value: Optional[_builtins.str] = None):
+        if static_value is not None:
+            pulumi.set(__self__, "static_value", static_value)
+
+    @_builtins.property
+    @pulumi.getter(name="staticValue")
+    def static_value(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "static_value")
+
+
+@pulumi.output_type
+class DataSetStringListFilterCondition(dict):
+    def __init__(__self__, *,
+                 operator: 'DataSetStringListFilterOperator',
+                 values: Optional['outputs.DataSetStringListFilterValue'] = None):
+        pulumi.set(__self__, "operator", operator)
+        if values is not None:
+            pulumi.set(__self__, "values", values)
+
+    @_builtins.property
+    @pulumi.getter
+    def operator(self) -> 'DataSetStringListFilterOperator':
+        return pulumi.get(self, "operator")
+
+    @_builtins.property
+    @pulumi.getter
+    def values(self) -> Optional['outputs.DataSetStringListFilterValue']:
+        return pulumi.get(self, "values")
+
+
+@pulumi.output_type
+class DataSetStringListFilterValue(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "staticValues":
+            suggest = "static_values"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetStringListFilterValue. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetStringListFilterValue.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetStringListFilterValue.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 static_values: Optional[Sequence[_builtins.str]] = None):
+        if static_values is not None:
+            pulumi.set(__self__, "static_values", static_values)
+
+    @_builtins.property
+    @pulumi.getter(name="staticValues")
+    def static_values(self) -> Optional[Sequence[_builtins.str]]:
+        return pulumi.get(self, "static_values")
+
+
+@pulumi.output_type
+class DataSetTablePathElement(dict):
+    def __init__(__self__, *,
+                 id: Optional[_builtins.str] = None,
+                 name: Optional[_builtins.str] = None):
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "id")
+
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "name")
+
+
 @pulumi.output_type
 class DataSetTagColumnOperation(dict):
     """
@@ -77848,6 +79724,175 @@ class DataSetTransformOperation(dict):
         return pulumi.get(self, "untag_column_operation")
 
 
+@pulumi.output_type
+class DataSetTransformOperationSource(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "transformOperationId":
+            suggest = "transform_operation_id"
+        elif key == "columnIdMappings":
+            suggest = "column_id_mappings"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetTransformOperationSource. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetTransformOperationSource.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetTransformOperationSource.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 transform_operation_id: _builtins.str,
+                 column_id_mappings: Optional[Sequence['outputs.DataSetColumnIdMapping']] = None):
+        pulumi.set(__self__, "transform_operation_id", transform_operation_id)
+        if column_id_mappings is not None:
+            pulumi.set(__self__, "column_id_mappings", column_id_mappings)
+
+    @_builtins.property
+    @pulumi.getter(name="transformOperationId")
+    def transform_operation_id(self) -> _builtins.str:
+        return pulumi.get(self, "transform_operation_id")
+
+    @_builtins.property
+    @pulumi.getter(name="columnIdMappings")
+    def column_id_mappings(self) -> Optional[Sequence['outputs.DataSetColumnIdMapping']]:
+        return pulumi.get(self, "column_id_mappings")
+
+
+@pulumi.output_type
+class DataSetTransformStep(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "aggregateStep":
+            suggest = "aggregate_step"
+        elif key == "appendStep":
+            suggest = "append_step"
+        elif key == "castColumnTypesStep":
+            suggest = "cast_column_types_step"
+        elif key == "createColumnsStep":
+            suggest = "create_columns_step"
+        elif key == "filtersStep":
+            suggest = "filters_step"
+        elif key == "importTableStep":
+            suggest = "import_table_step"
+        elif key == "joinStep":
+            suggest = "join_step"
+        elif key == "pivotStep":
+            suggest = "pivot_step"
+        elif key == "projectStep":
+            suggest = "project_step"
+        elif key == "renameColumnsStep":
+            suggest = "rename_columns_step"
+        elif key == "unpivotStep":
+            suggest = "unpivot_step"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetTransformStep. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetTransformStep.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetTransformStep.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 aggregate_step: Optional['outputs.DataSetAggregateOperation'] = None,
+                 append_step: Optional['outputs.DataSetAppendOperation'] = None,
+                 cast_column_types_step: Optional['outputs.DataSetCastColumnTypesOperation'] = None,
+                 create_columns_step: Optional['outputs.DataSetCreateColumnsOperation'] = None,
+                 filters_step: Optional['outputs.DataSetFiltersOperation'] = None,
+                 import_table_step: Optional['outputs.DataSetImportTableOperation'] = None,
+                 join_step: Optional['outputs.DataSetJoinOperation'] = None,
+                 pivot_step: Optional['outputs.DataSetPivotOperation'] = None,
+                 project_step: Optional['outputs.DataSetProjectOperation'] = None,
+                 rename_columns_step: Optional['outputs.DataSetRenameColumnsOperation'] = None,
+                 unpivot_step: Optional['outputs.DataSetUnpivotOperation'] = None):
+        if aggregate_step is not None:
+            pulumi.set(__self__, "aggregate_step", aggregate_step)
+        if append_step is not None:
+            pulumi.set(__self__, "append_step", append_step)
+        if cast_column_types_step is not None:
+            pulumi.set(__self__, "cast_column_types_step", cast_column_types_step)
+        if create_columns_step is not None:
+            pulumi.set(__self__, "create_columns_step", create_columns_step)
+        if filters_step is not None:
+            pulumi.set(__self__, "filters_step", filters_step)
+        if import_table_step is not None:
+            pulumi.set(__self__, "import_table_step", import_table_step)
+        if join_step is not None:
+            pulumi.set(__self__, "join_step", join_step)
+        if pivot_step is not None:
+            pulumi.set(__self__, "pivot_step", pivot_step)
+        if project_step is not None:
+            pulumi.set(__self__, "project_step", project_step)
+        if rename_columns_step is not None:
+            pulumi.set(__self__, "rename_columns_step", rename_columns_step)
+        if unpivot_step is not None:
+            pulumi.set(__self__, "unpivot_step", unpivot_step)
+
+    @_builtins.property
+    @pulumi.getter(name="aggregateStep")
+    def aggregate_step(self) -> Optional['outputs.DataSetAggregateOperation']:
+        return pulumi.get(self, "aggregate_step")
+
+    @_builtins.property
+    @pulumi.getter(name="appendStep")
+    def append_step(self) -> Optional['outputs.DataSetAppendOperation']:
+        return pulumi.get(self, "append_step")
+
+    @_builtins.property
+    @pulumi.getter(name="castColumnTypesStep")
+    def cast_column_types_step(self) -> Optional['outputs.DataSetCastColumnTypesOperation']:
+        return pulumi.get(self, "cast_column_types_step")
+
+    @_builtins.property
+    @pulumi.getter(name="createColumnsStep")
+    def create_columns_step(self) -> Optional['outputs.DataSetCreateColumnsOperation']:
+        return pulumi.get(self, "create_columns_step")
+
+    @_builtins.property
+    @pulumi.getter(name="filtersStep")
+    def filters_step(self) -> Optional['outputs.DataSetFiltersOperation']:
+        return pulumi.get(self, "filters_step")
+
+    @_builtins.property
+    @pulumi.getter(name="importTableStep")
+    def import_table_step(self) -> Optional['outputs.DataSetImportTableOperation']:
+        return pulumi.get(self, "import_table_step")
+
+    @_builtins.property
+    @pulumi.getter(name="joinStep")
+    def join_step(self) -> Optional['outputs.DataSetJoinOperation']:
+        return pulumi.get(self, "join_step")
+
+    @_builtins.property
+    @pulumi.getter(name="pivotStep")
+    def pivot_step(self) -> Optional['outputs.DataSetPivotOperation']:
+        return pulumi.get(self, "pivot_step")
+
+    @_builtins.property
+    @pulumi.getter(name="projectStep")
+    def project_step(self) -> Optional['outputs.DataSetProjectOperation']:
+        return pulumi.get(self, "project_step")
+
+    @_builtins.property
+    @pulumi.getter(name="renameColumnsStep")
+    def rename_columns_step(self) -> Optional['outputs.DataSetRenameColumnsOperation']:
+        return pulumi.get(self, "rename_columns_step")
+
+    @_builtins.property
+    @pulumi.getter(name="unpivotStep")
+    def unpivot_step(self) -> Optional['outputs.DataSetUnpivotOperation']:
+        return pulumi.get(self, "unpivot_step")
+
+
 @pulumi.output_type
 class DataSetUniqueKey(dict):
     @staticmethod
@@ -77868,16 +79913,94 @@ class DataSetUniqueKey(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 column_names: Optional[Sequence[_builtins.str]] = None):
-        if column_names is not None:
-            pulumi.set(__self__, "column_names", column_names)
+                 column_names: Sequence[_builtins.str]):
+        pulumi.set(__self__, "column_names", column_names)
 
     @_builtins.property
     @pulumi.getter(name="columnNames")
-    def column_names(self) -> Optional[Sequence[_builtins.str]]:
+    def column_names(self) -> Sequence[_builtins.str]:
         return pulumi.get(self, "column_names")
 
 
+@pulumi.output_type
+class DataSetUnpivotOperation(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "columnsToUnpivot":
+            suggest = "columns_to_unpivot"
+        elif key == "unpivotedLabelColumnId":
+            suggest = "unpivoted_label_column_id"
+        elif key == "unpivotedLabelColumnName":
+            suggest = "unpivoted_label_column_name"
+        elif key == "unpivotedValueColumnId":
+            suggest = "unpivoted_value_column_id"
+        elif key == "unpivotedValueColumnName":
+            suggest = "unpivoted_value_column_name"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetUnpivotOperation. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetUnpivotOperation.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetUnpivotOperation.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 alias: _builtins.str,
+                 columns_to_unpivot: Sequence['outputs.DataSetColumnToUnpivot'],
+                 source: 'outputs.DataSetTransformOperationSource',
+                 unpivoted_label_column_id: _builtins.str,
+                 unpivoted_label_column_name: _builtins.str,
+                 unpivoted_value_column_id: _builtins.str,
+                 unpivoted_value_column_name: _builtins.str):
+        pulumi.set(__self__, "alias", alias)
+        pulumi.set(__self__, "columns_to_unpivot", columns_to_unpivot)
+        pulumi.set(__self__, "source", source)
+        pulumi.set(__self__, "unpivoted_label_column_id", unpivoted_label_column_id)
+        pulumi.set(__self__, "unpivoted_label_column_name", unpivoted_label_column_name)
+        pulumi.set(__self__, "unpivoted_value_column_id", unpivoted_value_column_id)
+        pulumi.set(__self__, "unpivoted_value_column_name", unpivoted_value_column_name)
+
+    @_builtins.property
+    @pulumi.getter
+    def alias(self) -> _builtins.str:
+        return pulumi.get(self, "alias")
+
+    @_builtins.property
+    @pulumi.getter(name="columnsToUnpivot")
+    def columns_to_unpivot(self) -> Sequence['outputs.DataSetColumnToUnpivot']:
+        return pulumi.get(self, "columns_to_unpivot")
+
+    @_builtins.property
+    @pulumi.getter
+    def source(self) -> 'outputs.DataSetTransformOperationSource':
+        return pulumi.get(self, "source")
+
+    @_builtins.property
+    @pulumi.getter(name="unpivotedLabelColumnId")
+    def unpivoted_label_column_id(self) -> _builtins.str:
+        return pulumi.get(self, "unpivoted_label_column_id")
+
+    @_builtins.property
+    @pulumi.getter(name="unpivotedLabelColumnName")
+    def unpivoted_label_column_name(self) -> _builtins.str:
+        return pulumi.get(self, "unpivoted_label_column_name")
+
+    @_builtins.property
+    @pulumi.getter(name="unpivotedValueColumnId")
+    def unpivoted_value_column_id(self) -> _builtins.str:
+        return pulumi.get(self, "unpivoted_value_column_id")
+
+    @_builtins.property
+    @pulumi.getter(name="unpivotedValueColumnName")
+    def unpivoted_value_column_name(self) -> _builtins.str:
+        return pulumi.get(self, "unpivoted_value_column_name")
+
+
 @pulumi.output_type
 class DataSetUntagColumnOperation(dict):
     """
@@ -78076,6 +80199,36 @@ class DataSetUsageConfiguration(dict):
         return pulumi.get(self, "disable_use_as_imported_source")
 
 
+@pulumi.output_type
+class DataSetValueColumnConfiguration(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "aggregationFunction":
+            suggest = "aggregation_function"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DataSetValueColumnConfiguration. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DataSetValueColumnConfiguration.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DataSetValueColumnConfiguration.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 aggregation_function: Optional['outputs.DataSetDataPrepAggregationFunction'] = None):
+        if aggregation_function is not None:
+            pulumi.set(__self__, "aggregation_function", aggregation_function)
+
+    @_builtins.property
+    @pulumi.getter(name="aggregationFunction")
+    def aggregation_function(self) -> Optional['outputs.DataSetDataPrepAggregationFunction']:
+        return pulumi.get(self, "aggregation_function")
+
+
 @pulumi.output_type
 class DataSourceAmazonElasticsearchParameters(dict):
     """