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

pulumi_aws_native/quicksight/_inputs.py

@@ -2272,24 +2272,56 @@ __all__ = [
     'DashboardWordCloudVisualArgsDict',
     'DashboardYAxisOptionsArgs',
     'DashboardYAxisOptionsArgsDict',
+    'DataSetAggregateOperationArgs',
+    'DataSetAggregateOperationArgsDict',
+    'DataSetAggregationArgs',
+    'DataSetAggregationArgsDict',
+    'DataSetAppendOperationArgs',
+    'DataSetAppendOperationArgsDict',
+    'DataSetAppendedColumnArgs',
+    'DataSetAppendedColumnArgsDict',
     'DataSetCalculatedColumnArgs',
     'DataSetCalculatedColumnArgsDict',
     'DataSetCastColumnTypeOperationArgs',
     'DataSetCastColumnTypeOperationArgsDict',
+    'DataSetCastColumnTypesOperationArgs',
+    'DataSetCastColumnTypesOperationArgsDict',
     'DataSetColumnDescriptionArgs',
     'DataSetColumnDescriptionArgsDict',
     'DataSetColumnGroupArgs',
     'DataSetColumnGroupArgsDict',
+    'DataSetColumnIdMappingArgs',
+    'DataSetColumnIdMappingArgsDict',
     'DataSetColumnLevelPermissionRuleArgs',
     'DataSetColumnLevelPermissionRuleArgsDict',
     'DataSetColumnTagArgs',
     'DataSetColumnTagArgsDict',
+    'DataSetColumnToUnpivotArgs',
+    'DataSetColumnToUnpivotArgsDict',
     'DataSetCreateColumnsOperationArgs',
     'DataSetCreateColumnsOperationArgsDict',
     'DataSetCustomSqlArgs',
     'DataSetCustomSqlArgsDict',
+    'DataSetDataPrepAggregationFunctionArgs',
+    'DataSetDataPrepAggregationFunctionArgsDict',
+    'DataSetDataPrepConfigurationArgs',
+    'DataSetDataPrepConfigurationArgsDict',
+    'DataSetDataPrepListAggregationFunctionArgs',
+    'DataSetDataPrepListAggregationFunctionArgsDict',
+    'DataSetDataPrepPercentileAggregationFunctionArgs',
+    'DataSetDataPrepPercentileAggregationFunctionArgsDict',
+    'DataSetDataPrepSimpleAggregationFunctionArgs',
+    'DataSetDataPrepSimpleAggregationFunctionArgsDict',
     'DataSetDatasetParameterArgs',
     'DataSetDatasetParameterArgsDict',
+    'DataSetDateComparisonFilterConditionArgs',
+    'DataSetDateComparisonFilterConditionArgsDict',
+    'DataSetDateFilterConditionArgs',
+    'DataSetDateFilterConditionArgsDict',
+    'DataSetDateFilterValueArgs',
+    'DataSetDateFilterValueArgsDict',
+    'DataSetDateRangeFilterConditionArgs',
+    'DataSetDateRangeFilterConditionArgsDict',
     'DataSetDateTimeDatasetParameterDefaultValuesArgs',
     'DataSetDateTimeDatasetParameterDefaultValuesArgsDict',
     'DataSetDateTimeDatasetParameterArgs',
@@ -2298,12 +2330,22 @@ __all__ = [
     'DataSetDecimalDatasetParameterDefaultValuesArgsDict',
     'DataSetDecimalDatasetParameterArgs',
     'DataSetDecimalDatasetParameterArgsDict',
+    'DataSetDestinationTableSourceArgs',
+    'DataSetDestinationTableSourceArgsDict',
+    'DataSetDestinationTableArgs',
+    'DataSetDestinationTableArgsDict',
     'DataSetFieldFolderArgs',
     'DataSetFieldFolderArgsDict',
     'DataSetFilterOperationArgs',
     'DataSetFilterOperationArgsDict',
+    'DataSetFiltersOperationArgs',
+    'DataSetFiltersOperationArgsDict',
     'DataSetGeoSpatialColumnGroupArgs',
     'DataSetGeoSpatialColumnGroupArgsDict',
+    'DataSetImportTableOperationSourceArgs',
+    'DataSetImportTableOperationSourceArgsDict',
+    'DataSetImportTableOperationArgs',
+    'DataSetImportTableOperationArgsDict',
     'DataSetIncrementalRefreshArgs',
     'DataSetIncrementalRefreshArgsDict',
     'DataSetIngestionWaitPolicyArgs',
@@ -2318,6 +2360,10 @@ __all__ = [
     'DataSetJoinInstructionArgsDict',
     'DataSetJoinKeyPropertiesArgs',
     'DataSetJoinKeyPropertiesArgsDict',
+    'DataSetJoinOperandPropertiesArgs',
+    'DataSetJoinOperandPropertiesArgsDict',
+    'DataSetJoinOperationArgs',
+    'DataSetJoinOperationArgsDict',
     'DataSetLogicalTableSourceArgs',
     'DataSetLogicalTableSourceArgsDict',
     'DataSetLogicalTableArgs',
@@ -2326,12 +2372,30 @@ __all__ = [
     'DataSetLookbackWindowArgsDict',
     'DataSetNewDefaultValuesArgs',
     'DataSetNewDefaultValuesArgsDict',
+    'DataSetNumericComparisonFilterConditionArgs',
+    'DataSetNumericComparisonFilterConditionArgsDict',
+    'DataSetNumericFilterConditionArgs',
+    'DataSetNumericFilterConditionArgsDict',
+    'DataSetNumericFilterValueArgs',
+    'DataSetNumericFilterValueArgsDict',
+    'DataSetNumericRangeFilterConditionArgs',
+    'DataSetNumericRangeFilterConditionArgsDict',
+    'DataSetOutputColumnNameOverrideArgs',
+    'DataSetOutputColumnNameOverrideArgsDict',
     'DataSetOverrideDatasetParameterOperationArgs',
     'DataSetOverrideDatasetParameterOperationArgsDict',
+    'DataSetParentDataSetArgs',
+    'DataSetParentDataSetArgsDict',
     'DataSetPerformanceConfigurationArgs',
     'DataSetPerformanceConfigurationArgsDict',
     'DataSetPhysicalTableArgs',
     'DataSetPhysicalTableArgsDict',
+    'DataSetPivotConfigurationArgs',
+    'DataSetPivotConfigurationArgsDict',
+    'DataSetPivotOperationArgs',
+    'DataSetPivotOperationArgsDict',
+    'DataSetPivotedLabelArgs',
+    'DataSetPivotedLabelArgsDict',
     'DataSetProjectOperationArgs',
     'DataSetProjectOperationArgsDict',
     'DataSetRefreshConfigurationArgs',
@@ -2346,8 +2410,12 @@ __all__ = [
     'DataSetRelationalTableArgsDict',
     'DataSetRenameColumnOperationArgs',
     'DataSetRenameColumnOperationArgsDict',
+    'DataSetRenameColumnsOperationArgs',
+    'DataSetRenameColumnsOperationArgsDict',
     'DataSetResourcePermissionArgs',
     'DataSetResourcePermissionArgsDict',
+    'DataSetRowLevelPermissionConfigurationArgs',
+    'DataSetRowLevelPermissionConfigurationArgsDict',
     'DataSetRowLevelPermissionDataSetArgs',
     'DataSetRowLevelPermissionDataSetArgsDict',
     'DataSetRowLevelPermissionTagConfigurationArgs',
@@ -2356,22 +2424,50 @@ __all__ = [
     'DataSetRowLevelPermissionTagRuleArgsDict',
     'DataSetS3SourceArgs',
     'DataSetS3SourceArgsDict',
+    'DataSetSaaSTableArgs',
+    'DataSetSaaSTableArgsDict',
+    'DataSetSemanticModelConfigurationArgs',
+    'DataSetSemanticModelConfigurationArgsDict',
+    'DataSetSemanticTableArgs',
+    'DataSetSemanticTableArgsDict',
+    'DataSetSourceTableArgs',
+    'DataSetSourceTableArgsDict',
+    'DataSetStringComparisonFilterConditionArgs',
+    'DataSetStringComparisonFilterConditionArgsDict',
     'DataSetStringDatasetParameterDefaultValuesArgs',
     'DataSetStringDatasetParameterDefaultValuesArgsDict',
     'DataSetStringDatasetParameterArgs',
     'DataSetStringDatasetParameterArgsDict',
+    'DataSetStringFilterConditionArgs',
+    'DataSetStringFilterConditionArgsDict',
+    'DataSetStringFilterValueArgs',
+    'DataSetStringFilterValueArgsDict',
+    'DataSetStringListFilterConditionArgs',
+    'DataSetStringListFilterConditionArgsDict',
+    'DataSetStringListFilterValueArgs',
+    'DataSetStringListFilterValueArgsDict',
+    'DataSetTablePathElementArgs',
+    'DataSetTablePathElementArgsDict',
     'DataSetTagColumnOperationArgs',
     'DataSetTagColumnOperationArgsDict',
+    'DataSetTransformOperationSourceArgs',
+    'DataSetTransformOperationSourceArgsDict',
     'DataSetTransformOperationArgs',
     'DataSetTransformOperationArgsDict',
+    'DataSetTransformStepArgs',
+    'DataSetTransformStepArgsDict',
     'DataSetUniqueKeyArgs',
     'DataSetUniqueKeyArgsDict',
+    'DataSetUnpivotOperationArgs',
+    'DataSetUnpivotOperationArgsDict',
     'DataSetUntagColumnOperationArgs',
     'DataSetUntagColumnOperationArgsDict',
     'DataSetUploadSettingsArgs',
     'DataSetUploadSettingsArgsDict',
     'DataSetUsageConfigurationArgs',
     'DataSetUsageConfigurationArgsDict',
+    'DataSetValueColumnConfigurationArgs',
+    'DataSetValueColumnConfigurationArgsDict',
     'DataSourceAmazonElasticsearchParametersArgs',
     'DataSourceAmazonElasticsearchParametersArgsDict',
     'DataSourceAmazonOpenSearchParametersArgs',
@@ -92686,6 +92782,205 @@ class DashboardYAxisOptionsArgs:
         pulumi.set(self, "y_axis", value)
 
 
+if not MYPY:
+    class DataSetAggregateOperationArgsDict(TypedDict):
+        aggregations: pulumi.Input[Sequence[pulumi.Input['DataSetAggregationArgsDict']]]
+        alias: pulumi.Input[_builtins.str]
+        source: pulumi.Input['DataSetTransformOperationSourceArgsDict']
+        group_by_column_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
+elif False:
+    DataSetAggregateOperationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetAggregateOperationArgs:
+    def __init__(__self__, *,
+                 aggregations: pulumi.Input[Sequence[pulumi.Input['DataSetAggregationArgs']]],
+                 alias: pulumi.Input[_builtins.str],
+                 source: pulumi.Input['DataSetTransformOperationSourceArgs'],
+                 group_by_column_names: Optional[pulumi.Input[Sequence[pulumi.Input[_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) -> pulumi.Input[Sequence[pulumi.Input['DataSetAggregationArgs']]]:
+        return pulumi.get(self, "aggregations")
+
+    @aggregations.setter
+    def aggregations(self, value: pulumi.Input[Sequence[pulumi.Input['DataSetAggregationArgs']]]):
+        pulumi.set(self, "aggregations", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def alias(self) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "alias")
+
+    @alias.setter
+    def alias(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "alias", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def source(self) -> pulumi.Input['DataSetTransformOperationSourceArgs']:
+        return pulumi.get(self, "source")
+
+    @source.setter
+    def source(self, value: pulumi.Input['DataSetTransformOperationSourceArgs']):
+        pulumi.set(self, "source", value)
+
+    @_builtins.property
+    @pulumi.getter(name="groupByColumnNames")
+    def group_by_column_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
+        return pulumi.get(self, "group_by_column_names")
+
+    @group_by_column_names.setter
+    def group_by_column_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
+        pulumi.set(self, "group_by_column_names", value)
+
+
+if not MYPY:
+    class DataSetAggregationArgsDict(TypedDict):
+        aggregation_function: pulumi.Input['DataSetDataPrepAggregationFunctionArgsDict']
+        new_column_id: pulumi.Input[_builtins.str]
+        new_column_name: pulumi.Input[_builtins.str]
+elif False:
+    DataSetAggregationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetAggregationArgs:
+    def __init__(__self__, *,
+                 aggregation_function: pulumi.Input['DataSetDataPrepAggregationFunctionArgs'],
+                 new_column_id: pulumi.Input[_builtins.str],
+                 new_column_name: pulumi.Input[_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) -> pulumi.Input['DataSetDataPrepAggregationFunctionArgs']:
+        return pulumi.get(self, "aggregation_function")
+
+    @aggregation_function.setter
+    def aggregation_function(self, value: pulumi.Input['DataSetDataPrepAggregationFunctionArgs']):
+        pulumi.set(self, "aggregation_function", value)
+
+    @_builtins.property
+    @pulumi.getter(name="newColumnId")
+    def new_column_id(self) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "new_column_id")
+
+    @new_column_id.setter
+    def new_column_id(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "new_column_id", value)
+
+    @_builtins.property
+    @pulumi.getter(name="newColumnName")
+    def new_column_name(self) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "new_column_name")
+
+    @new_column_name.setter
+    def new_column_name(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "new_column_name", value)
+
+
+if not MYPY:
+    class DataSetAppendOperationArgsDict(TypedDict):
+        alias: pulumi.Input[_builtins.str]
+        appended_columns: pulumi.Input[Sequence[pulumi.Input['DataSetAppendedColumnArgsDict']]]
+        first_source: NotRequired[pulumi.Input['DataSetTransformOperationSourceArgsDict']]
+        second_source: NotRequired[pulumi.Input['DataSetTransformOperationSourceArgsDict']]
+elif False:
+    DataSetAppendOperationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetAppendOperationArgs:
+    def __init__(__self__, *,
+                 alias: pulumi.Input[_builtins.str],
+                 appended_columns: pulumi.Input[Sequence[pulumi.Input['DataSetAppendedColumnArgs']]],
+                 first_source: Optional[pulumi.Input['DataSetTransformOperationSourceArgs']] = None,
+                 second_source: Optional[pulumi.Input['DataSetTransformOperationSourceArgs']] = 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) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "alias")
+
+    @alias.setter
+    def alias(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "alias", value)
+
+    @_builtins.property
+    @pulumi.getter(name="appendedColumns")
+    def appended_columns(self) -> pulumi.Input[Sequence[pulumi.Input['DataSetAppendedColumnArgs']]]:
+        return pulumi.get(self, "appended_columns")
+
+    @appended_columns.setter
+    def appended_columns(self, value: pulumi.Input[Sequence[pulumi.Input['DataSetAppendedColumnArgs']]]):
+        pulumi.set(self, "appended_columns", value)
+
+    @_builtins.property
+    @pulumi.getter(name="firstSource")
+    def first_source(self) -> Optional[pulumi.Input['DataSetTransformOperationSourceArgs']]:
+        return pulumi.get(self, "first_source")
+
+    @first_source.setter
+    def first_source(self, value: Optional[pulumi.Input['DataSetTransformOperationSourceArgs']]):
+        pulumi.set(self, "first_source", value)
+
+    @_builtins.property
+    @pulumi.getter(name="secondSource")
+    def second_source(self) -> Optional[pulumi.Input['DataSetTransformOperationSourceArgs']]:
+        return pulumi.get(self, "second_source")
+
+    @second_source.setter
+    def second_source(self, value: Optional[pulumi.Input['DataSetTransformOperationSourceArgs']]):
+        pulumi.set(self, "second_source", value)
+
+
+if not MYPY:
+    class DataSetAppendedColumnArgsDict(TypedDict):
+        column_name: pulumi.Input[_builtins.str]
+        new_column_id: pulumi.Input[_builtins.str]
+elif False:
+    DataSetAppendedColumnArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetAppendedColumnArgs:
+    def __init__(__self__, *,
+                 column_name: pulumi.Input[_builtins.str],
+                 new_column_id: pulumi.Input[_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) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "column_name")
+
+    @column_name.setter
+    def column_name(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "column_name", value)
+
+    @_builtins.property
+    @pulumi.getter(name="newColumnId")
+    def new_column_id(self) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "new_column_id")
+
+    @new_column_id.setter
+    def new_column_id(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "new_column_id", value)
+
+
 if not MYPY:
     class DataSetCalculatedColumnArgsDict(TypedDict):
         """
@@ -92770,13 +93065,13 @@ if not MYPY:
         """
         <p>A transform operation that casts a column to a different type.</p>
         """
-        new_column_type: pulumi.Input['DataSetColumnDataType']
+        column_name: pulumi.Input[_builtins.str]
         """
-        New column data type.
+        <p>Column name.</p>
         """
-        column_name: NotRequired[pulumi.Input[_builtins.str]]
+        new_column_type: pulumi.Input['DataSetColumnDataType']
         """
-        <p>Column name.</p>
+        New column data type.
         """
         format: NotRequired[pulumi.Input[_builtins.str]]
         """
@@ -92793,26 +93088,37 @@ elif False:
 @pulumi.input_type
 class DataSetCastColumnTypeOperationArgs:
     def __init__(__self__, *,
+                 column_name: pulumi.Input[_builtins.str],
                  new_column_type: pulumi.Input['DataSetColumnDataType'],
-                 column_name: Optional[pulumi.Input[_builtins.str]] = None,
                  format: Optional[pulumi.Input[_builtins.str]] = None,
                  sub_type: Optional[pulumi.Input['DataSetColumnDataSubType']] = None):
         """
         <p>A transform operation that casts a column to a different type.</p>
-        :param pulumi.Input['DataSetColumnDataType'] new_column_type: New column data type.
         :param pulumi.Input[_builtins.str] column_name: <p>Column name.</p>
+        :param pulumi.Input['DataSetColumnDataType'] new_column_type: New column data type.
         :param pulumi.Input[_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 pulumi.Input['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="columnName")
+    def column_name(self) -> pulumi.Input[_builtins.str]:
+        """
+        <p>Column name.</p>
+        """
+        return pulumi.get(self, "column_name")
+
+    @column_name.setter
+    def column_name(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "column_name", value)
+
     @_builtins.property
     @pulumi.getter(name="newColumnType")
     def new_column_type(self) -> pulumi.Input['DataSetColumnDataType']:
@@ -92825,18 +93131,6 @@ class DataSetCastColumnTypeOperationArgs:
     def new_column_type(self, value: pulumi.Input['DataSetColumnDataType']):
         pulumi.set(self, "new_column_type", value)
 
-    @_builtins.property
-    @pulumi.getter(name="columnName")
-    def column_name(self) -> Optional[pulumi.Input[_builtins.str]]:
-        """
-        <p>Column name.</p>
-        """
-        return pulumi.get(self, "column_name")
-
-    @column_name.setter
-    def column_name(self, value: Optional[pulumi.Input[_builtins.str]]):
-        pulumi.set(self, "column_name", value)
-
     @_builtins.property
     @pulumi.getter
     def format(self) -> Optional[pulumi.Input[_builtins.str]]:
@@ -92863,6 +93157,52 @@ class DataSetCastColumnTypeOperationArgs:
         pulumi.set(self, "sub_type", value)
 
 
+if not MYPY:
+    class DataSetCastColumnTypesOperationArgsDict(TypedDict):
+        alias: pulumi.Input[_builtins.str]
+        cast_column_type_operations: pulumi.Input[Sequence[pulumi.Input['DataSetCastColumnTypeOperationArgsDict']]]
+        source: pulumi.Input['DataSetTransformOperationSourceArgsDict']
+elif False:
+    DataSetCastColumnTypesOperationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetCastColumnTypesOperationArgs:
+    def __init__(__self__, *,
+                 alias: pulumi.Input[_builtins.str],
+                 cast_column_type_operations: pulumi.Input[Sequence[pulumi.Input['DataSetCastColumnTypeOperationArgs']]],
+                 source: pulumi.Input['DataSetTransformOperationSourceArgs']):
+        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) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "alias")
+
+    @alias.setter
+    def alias(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "alias", value)
+
+    @_builtins.property
+    @pulumi.getter(name="castColumnTypeOperations")
+    def cast_column_type_operations(self) -> pulumi.Input[Sequence[pulumi.Input['DataSetCastColumnTypeOperationArgs']]]:
+        return pulumi.get(self, "cast_column_type_operations")
+
+    @cast_column_type_operations.setter
+    def cast_column_type_operations(self, value: pulumi.Input[Sequence[pulumi.Input['DataSetCastColumnTypeOperationArgs']]]):
+        pulumi.set(self, "cast_column_type_operations", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def source(self) -> pulumi.Input['DataSetTransformOperationSourceArgs']:
+        return pulumi.get(self, "source")
+
+    @source.setter
+    def source(self, value: pulumi.Input['DataSetTransformOperationSourceArgs']):
+        pulumi.set(self, "source", value)
+
+
 if not MYPY:
     class DataSetColumnDescriptionArgsDict(TypedDict):
         """
@@ -92939,6 +93279,40 @@ class DataSetColumnGroupArgs:
         pulumi.set(self, "geo_spatial_column_group", value)
 
 
+if not MYPY:
+    class DataSetColumnIdMappingArgsDict(TypedDict):
+        source_column_id: pulumi.Input[_builtins.str]
+        target_column_id: pulumi.Input[_builtins.str]
+elif False:
+    DataSetColumnIdMappingArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetColumnIdMappingArgs:
+    def __init__(__self__, *,
+                 source_column_id: pulumi.Input[_builtins.str],
+                 target_column_id: pulumi.Input[_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) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "source_column_id")
+
+    @source_column_id.setter
+    def source_column_id(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "source_column_id", value)
+
+    @_builtins.property
+    @pulumi.getter(name="targetColumnId")
+    def target_column_id(self) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "target_column_id")
+
+    @target_column_id.setter
+    def target_column_id(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "target_column_id", value)
+
+
 if not MYPY:
     class DataSetColumnLevelPermissionRuleArgsDict(TypedDict):
         """
@@ -93073,49 +93447,114 @@ class DataSetColumnTagArgs:
         pulumi.set(self, "column_geographic_role", value)
 
 
+if not MYPY:
+    class DataSetColumnToUnpivotArgsDict(TypedDict):
+        column_name: NotRequired[pulumi.Input[_builtins.str]]
+        new_value: NotRequired[pulumi.Input[_builtins.str]]
+elif False:
+    DataSetColumnToUnpivotArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetColumnToUnpivotArgs:
+    def __init__(__self__, *,
+                 column_name: Optional[pulumi.Input[_builtins.str]] = None,
+                 new_value: Optional[pulumi.Input[_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[pulumi.Input[_builtins.str]]:
+        return pulumi.get(self, "column_name")
+
+    @column_name.setter
+    def column_name(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "column_name", value)
+
+    @_builtins.property
+    @pulumi.getter(name="newValue")
+    def new_value(self) -> Optional[pulumi.Input[_builtins.str]]:
+        return pulumi.get(self, "new_value")
+
+    @new_value.setter
+    def new_value(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "new_value", value)
+
+
 if not MYPY:
     class DataSetCreateColumnsOperationArgsDict(TypedDict):
         """
         <p>A transform operation that creates calculated columns. Columns created in one such
                     operation form a lexical closure.</p>
         """
-        columns: NotRequired[pulumi.Input[Sequence[pulumi.Input['DataSetCalculatedColumnArgsDict']]]]
+        columns: pulumi.Input[Sequence[pulumi.Input['DataSetCalculatedColumnArgsDict']]]
         """
         <p>Calculated columns to create.</p>
         """
+        alias: NotRequired[pulumi.Input[_builtins.str]]
+        source: NotRequired[pulumi.Input['DataSetTransformOperationSourceArgsDict']]
 elif False:
     DataSetCreateColumnsOperationArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class DataSetCreateColumnsOperationArgs:
     def __init__(__self__, *,
-                 columns: Optional[pulumi.Input[Sequence[pulumi.Input['DataSetCalculatedColumnArgs']]]] = None):
+                 columns: pulumi.Input[Sequence[pulumi.Input['DataSetCalculatedColumnArgs']]],
+                 alias: Optional[pulumi.Input[_builtins.str]] = None,
+                 source: Optional[pulumi.Input['DataSetTransformOperationSourceArgs']] = None):
         """
         <p>A transform operation that creates calculated columns. Columns created in one such
                     operation form a lexical closure.</p>
         :param pulumi.Input[Sequence[pulumi.Input['DataSetCalculatedColumnArgs']]] 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[pulumi.Input[Sequence[pulumi.Input['DataSetCalculatedColumnArgs']]]]:
+    def columns(self) -> pulumi.Input[Sequence[pulumi.Input['DataSetCalculatedColumnArgs']]]:
         """
         <p>Calculated columns to create.</p>
         """
         return pulumi.get(self, "columns")
 
     @columns.setter
-    def columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataSetCalculatedColumnArgs']]]]):
+    def columns(self, value: pulumi.Input[Sequence[pulumi.Input['DataSetCalculatedColumnArgs']]]):
         pulumi.set(self, "columns", value)
 
+    @_builtins.property
+    @pulumi.getter
+    def alias(self) -> Optional[pulumi.Input[_builtins.str]]:
+        return pulumi.get(self, "alias")
+
+    @alias.setter
+    def alias(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "alias", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def source(self) -> Optional[pulumi.Input['DataSetTransformOperationSourceArgs']]:
+        return pulumi.get(self, "source")
+
+    @source.setter
+    def source(self, value: Optional[pulumi.Input['DataSetTransformOperationSourceArgs']]):
+        pulumi.set(self, "source", value)
+
 
 if not MYPY:
     class DataSetCustomSqlArgsDict(TypedDict):
         """
         <p>A physical table type built from the results of the custom SQL query.</p>
         """
+        columns: pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgsDict']]]
+        """
+        <p>The column schema from the SQL query result set.</p>
+        """
         data_source_arn: pulumi.Input[_builtins.str]
         """
         <p>The Amazon Resource Name (ARN) of the data source.</p>
@@ -93128,32 +93567,39 @@ if not MYPY:
         """
         <p>The SQL query.</p>
         """
-        columns: NotRequired[pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgsDict']]]]
-        """
-        <p>The column schema from the SQL query result set.</p>
-        """
 elif False:
     DataSetCustomSqlArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class DataSetCustomSqlArgs:
     def __init__(__self__, *,
+                 columns: pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]],
                  data_source_arn: pulumi.Input[_builtins.str],
                  name: pulumi.Input[_builtins.str],
-                 sql_query: pulumi.Input[_builtins.str],
-                 columns: Optional[pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]]] = None):
+                 sql_query: pulumi.Input[_builtins.str]):
         """
         <p>A physical table type built from the results of the custom SQL query.</p>
+        :param pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]] columns: <p>The column schema from the SQL query result set.</p>
         :param pulumi.Input[_builtins.str] data_source_arn: <p>The Amazon Resource Name (ARN) of the data source.</p>
         :param pulumi.Input[_builtins.str] name: <p>A display name for the SQL query result.</p>
         :param pulumi.Input[_builtins.str] sql_query: <p>The SQL query.</p>
-        :param pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]] 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) -> pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]]:
+        """
+        <p>The column schema from the SQL query result set.</p>
+        """
+        return pulumi.get(self, "columns")
+
+    @columns.setter
+    def columns(self, value: pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]]):
+        pulumi.set(self, "columns", value)
 
     @_builtins.property
     @pulumi.getter(name="dataSourceArn")
@@ -93191,17 +93637,217 @@ class DataSetCustomSqlArgs:
     def sql_query(self, value: pulumi.Input[_builtins.str]):
         pulumi.set(self, "sql_query", value)
 
+
+if not MYPY:
+    class DataSetDataPrepAggregationFunctionArgsDict(TypedDict):
+        list_aggregation: NotRequired[pulumi.Input['DataSetDataPrepListAggregationFunctionArgsDict']]
+        percentile_aggregation: NotRequired[pulumi.Input['DataSetDataPrepPercentileAggregationFunctionArgsDict']]
+        simple_aggregation: NotRequired[pulumi.Input['DataSetDataPrepSimpleAggregationFunctionArgsDict']]
+elif False:
+    DataSetDataPrepAggregationFunctionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetDataPrepAggregationFunctionArgs:
+    def __init__(__self__, *,
+                 list_aggregation: Optional[pulumi.Input['DataSetDataPrepListAggregationFunctionArgs']] = None,
+                 percentile_aggregation: Optional[pulumi.Input['DataSetDataPrepPercentileAggregationFunctionArgs']] = None,
+                 simple_aggregation: Optional[pulumi.Input['DataSetDataPrepSimpleAggregationFunctionArgs']] = 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[pulumi.Input['DataSetDataPrepListAggregationFunctionArgs']]:
+        return pulumi.get(self, "list_aggregation")
+
+    @list_aggregation.setter
+    def list_aggregation(self, value: Optional[pulumi.Input['DataSetDataPrepListAggregationFunctionArgs']]):
+        pulumi.set(self, "list_aggregation", value)
+
+    @_builtins.property
+    @pulumi.getter(name="percentileAggregation")
+    def percentile_aggregation(self) -> Optional[pulumi.Input['DataSetDataPrepPercentileAggregationFunctionArgs']]:
+        return pulumi.get(self, "percentile_aggregation")
+
+    @percentile_aggregation.setter
+    def percentile_aggregation(self, value: Optional[pulumi.Input['DataSetDataPrepPercentileAggregationFunctionArgs']]):
+        pulumi.set(self, "percentile_aggregation", value)
+
+    @_builtins.property
+    @pulumi.getter(name="simpleAggregation")
+    def simple_aggregation(self) -> Optional[pulumi.Input['DataSetDataPrepSimpleAggregationFunctionArgs']]:
+        return pulumi.get(self, "simple_aggregation")
+
+    @simple_aggregation.setter
+    def simple_aggregation(self, value: Optional[pulumi.Input['DataSetDataPrepSimpleAggregationFunctionArgs']]):
+        pulumi.set(self, "simple_aggregation", value)
+
+
+if not MYPY:
+    class DataSetDataPrepConfigurationArgsDict(TypedDict):
+        destination_table_map: pulumi.Input[Mapping[str, pulumi.Input['DataSetDestinationTableArgsDict']]]
+        source_table_map: pulumi.Input[Mapping[str, pulumi.Input['DataSetSourceTableArgsDict']]]
+        transform_step_map: pulumi.Input[Mapping[str, pulumi.Input['DataSetTransformStepArgsDict']]]
+elif False:
+    DataSetDataPrepConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetDataPrepConfigurationArgs:
+    def __init__(__self__, *,
+                 destination_table_map: pulumi.Input[Mapping[str, pulumi.Input['DataSetDestinationTableArgs']]],
+                 source_table_map: pulumi.Input[Mapping[str, pulumi.Input['DataSetSourceTableArgs']]],
+                 transform_step_map: pulumi.Input[Mapping[str, pulumi.Input['DataSetTransformStepArgs']]]):
+        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) -> pulumi.Input[Mapping[str, pulumi.Input['DataSetDestinationTableArgs']]]:
+        return pulumi.get(self, "destination_table_map")
+
+    @destination_table_map.setter
+    def destination_table_map(self, value: pulumi.Input[Mapping[str, pulumi.Input['DataSetDestinationTableArgs']]]):
+        pulumi.set(self, "destination_table_map", value)
+
+    @_builtins.property
+    @pulumi.getter(name="sourceTableMap")
+    def source_table_map(self) -> pulumi.Input[Mapping[str, pulumi.Input['DataSetSourceTableArgs']]]:
+        return pulumi.get(self, "source_table_map")
+
+    @source_table_map.setter
+    def source_table_map(self, value: pulumi.Input[Mapping[str, pulumi.Input['DataSetSourceTableArgs']]]):
+        pulumi.set(self, "source_table_map", value)
+
+    @_builtins.property
+    @pulumi.getter(name="transformStepMap")
+    def transform_step_map(self) -> pulumi.Input[Mapping[str, pulumi.Input['DataSetTransformStepArgs']]]:
+        return pulumi.get(self, "transform_step_map")
+
+    @transform_step_map.setter
+    def transform_step_map(self, value: pulumi.Input[Mapping[str, pulumi.Input['DataSetTransformStepArgs']]]):
+        pulumi.set(self, "transform_step_map", value)
+
+
+if not MYPY:
+    class DataSetDataPrepListAggregationFunctionArgsDict(TypedDict):
+        distinct: pulumi.Input[_builtins.bool]
+        separator: pulumi.Input[_builtins.str]
+        input_column_name: NotRequired[pulumi.Input[_builtins.str]]
+elif False:
+    DataSetDataPrepListAggregationFunctionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetDataPrepListAggregationFunctionArgs:
+    def __init__(__self__, *,
+                 distinct: pulumi.Input[_builtins.bool],
+                 separator: pulumi.Input[_builtins.str],
+                 input_column_name: Optional[pulumi.Input[_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[pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]]]:
-        """
-        <p>The column schema from the SQL query result set.</p>
-        """
-        return pulumi.get(self, "columns")
+    def distinct(self) -> pulumi.Input[_builtins.bool]:
+        return pulumi.get(self, "distinct")
 
-    @columns.setter
-    def columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]]]):
-        pulumi.set(self, "columns", value)
+    @distinct.setter
+    def distinct(self, value: pulumi.Input[_builtins.bool]):
+        pulumi.set(self, "distinct", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def separator(self) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "separator")
+
+    @separator.setter
+    def separator(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "separator", value)
+
+    @_builtins.property
+    @pulumi.getter(name="inputColumnName")
+    def input_column_name(self) -> Optional[pulumi.Input[_builtins.str]]:
+        return pulumi.get(self, "input_column_name")
+
+    @input_column_name.setter
+    def input_column_name(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "input_column_name", value)
+
+
+if not MYPY:
+    class DataSetDataPrepPercentileAggregationFunctionArgsDict(TypedDict):
+        percentile_value: pulumi.Input[_builtins.float]
+        input_column_name: NotRequired[pulumi.Input[_builtins.str]]
+elif False:
+    DataSetDataPrepPercentileAggregationFunctionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetDataPrepPercentileAggregationFunctionArgs:
+    def __init__(__self__, *,
+                 percentile_value: pulumi.Input[_builtins.float],
+                 input_column_name: Optional[pulumi.Input[_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) -> pulumi.Input[_builtins.float]:
+        return pulumi.get(self, "percentile_value")
+
+    @percentile_value.setter
+    def percentile_value(self, value: pulumi.Input[_builtins.float]):
+        pulumi.set(self, "percentile_value", value)
+
+    @_builtins.property
+    @pulumi.getter(name="inputColumnName")
+    def input_column_name(self) -> Optional[pulumi.Input[_builtins.str]]:
+        return pulumi.get(self, "input_column_name")
+
+    @input_column_name.setter
+    def input_column_name(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "input_column_name", value)
+
+
+if not MYPY:
+    class DataSetDataPrepSimpleAggregationFunctionArgsDict(TypedDict):
+        function_type: pulumi.Input['DataSetDataPrepSimpleAggregationFunctionType']
+        input_column_name: NotRequired[pulumi.Input[_builtins.str]]
+elif False:
+    DataSetDataPrepSimpleAggregationFunctionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetDataPrepSimpleAggregationFunctionArgs:
+    def __init__(__self__, *,
+                 function_type: pulumi.Input['DataSetDataPrepSimpleAggregationFunctionType'],
+                 input_column_name: Optional[pulumi.Input[_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) -> pulumi.Input['DataSetDataPrepSimpleAggregationFunctionType']:
+        return pulumi.get(self, "function_type")
+
+    @function_type.setter
+    def function_type(self, value: pulumi.Input['DataSetDataPrepSimpleAggregationFunctionType']):
+        pulumi.set(self, "function_type", value)
+
+    @_builtins.property
+    @pulumi.getter(name="inputColumnName")
+    def input_column_name(self) -> Optional[pulumi.Input[_builtins.str]]:
+        return pulumi.get(self, "input_column_name")
+
+    @input_column_name.setter
+    def input_column_name(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "input_column_name", value)
 
 
 if not MYPY:
@@ -93300,6 +93946,175 @@ class DataSetDatasetParameterArgs:
         pulumi.set(self, "string_dataset_parameter", value)
 
 
+if not MYPY:
+    class DataSetDateComparisonFilterConditionArgsDict(TypedDict):
+        operator: pulumi.Input['DataSetDateComparisonFilterOperator']
+        value: NotRequired[pulumi.Input['DataSetDateFilterValueArgsDict']]
+elif False:
+    DataSetDateComparisonFilterConditionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetDateComparisonFilterConditionArgs:
+    def __init__(__self__, *,
+                 operator: pulumi.Input['DataSetDateComparisonFilterOperator'],
+                 value: Optional[pulumi.Input['DataSetDateFilterValueArgs']] = None):
+        pulumi.set(__self__, "operator", operator)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def operator(self) -> pulumi.Input['DataSetDateComparisonFilterOperator']:
+        return pulumi.get(self, "operator")
+
+    @operator.setter
+    def operator(self, value: pulumi.Input['DataSetDateComparisonFilterOperator']):
+        pulumi.set(self, "operator", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def value(self) -> Optional[pulumi.Input['DataSetDateFilterValueArgs']]:
+        return pulumi.get(self, "value")
+
+    @value.setter
+    def value(self, value: Optional[pulumi.Input['DataSetDateFilterValueArgs']]):
+        pulumi.set(self, "value", value)
+
+
+if not MYPY:
+    class DataSetDateFilterConditionArgsDict(TypedDict):
+        column_name: NotRequired[pulumi.Input[_builtins.str]]
+        comparison_filter_condition: NotRequired[pulumi.Input['DataSetDateComparisonFilterConditionArgsDict']]
+        range_filter_condition: NotRequired[pulumi.Input['DataSetDateRangeFilterConditionArgsDict']]
+elif False:
+    DataSetDateFilterConditionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetDateFilterConditionArgs:
+    def __init__(__self__, *,
+                 column_name: Optional[pulumi.Input[_builtins.str]] = None,
+                 comparison_filter_condition: Optional[pulumi.Input['DataSetDateComparisonFilterConditionArgs']] = None,
+                 range_filter_condition: Optional[pulumi.Input['DataSetDateRangeFilterConditionArgs']] = 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[pulumi.Input[_builtins.str]]:
+        return pulumi.get(self, "column_name")
+
+    @column_name.setter
+    def column_name(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "column_name", value)
+
+    @_builtins.property
+    @pulumi.getter(name="comparisonFilterCondition")
+    def comparison_filter_condition(self) -> Optional[pulumi.Input['DataSetDateComparisonFilterConditionArgs']]:
+        return pulumi.get(self, "comparison_filter_condition")
+
+    @comparison_filter_condition.setter
+    def comparison_filter_condition(self, value: Optional[pulumi.Input['DataSetDateComparisonFilterConditionArgs']]):
+        pulumi.set(self, "comparison_filter_condition", value)
+
+    @_builtins.property
+    @pulumi.getter(name="rangeFilterCondition")
+    def range_filter_condition(self) -> Optional[pulumi.Input['DataSetDateRangeFilterConditionArgs']]:
+        return pulumi.get(self, "range_filter_condition")
+
+    @range_filter_condition.setter
+    def range_filter_condition(self, value: Optional[pulumi.Input['DataSetDateRangeFilterConditionArgs']]):
+        pulumi.set(self, "range_filter_condition", value)
+
+
+if not MYPY:
+    class DataSetDateFilterValueArgsDict(TypedDict):
+        static_value: NotRequired[pulumi.Input[_builtins.str]]
+elif False:
+    DataSetDateFilterValueArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetDateFilterValueArgs:
+    def __init__(__self__, *,
+                 static_value: Optional[pulumi.Input[_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[pulumi.Input[_builtins.str]]:
+        return pulumi.get(self, "static_value")
+
+    @static_value.setter
+    def static_value(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "static_value", value)
+
+
+if not MYPY:
+    class DataSetDateRangeFilterConditionArgsDict(TypedDict):
+        include_maximum: NotRequired[pulumi.Input[_builtins.bool]]
+        include_minimum: NotRequired[pulumi.Input[_builtins.bool]]
+        range_maximum: NotRequired[pulumi.Input['DataSetDateFilterValueArgsDict']]
+        range_minimum: NotRequired[pulumi.Input['DataSetDateFilterValueArgsDict']]
+elif False:
+    DataSetDateRangeFilterConditionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetDateRangeFilterConditionArgs:
+    def __init__(__self__, *,
+                 include_maximum: Optional[pulumi.Input[_builtins.bool]] = None,
+                 include_minimum: Optional[pulumi.Input[_builtins.bool]] = None,
+                 range_maximum: Optional[pulumi.Input['DataSetDateFilterValueArgs']] = None,
+                 range_minimum: Optional[pulumi.Input['DataSetDateFilterValueArgs']] = 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[pulumi.Input[_builtins.bool]]:
+        return pulumi.get(self, "include_maximum")
+
+    @include_maximum.setter
+    def include_maximum(self, value: Optional[pulumi.Input[_builtins.bool]]):
+        pulumi.set(self, "include_maximum", value)
+
+    @_builtins.property
+    @pulumi.getter(name="includeMinimum")
+    def include_minimum(self) -> Optional[pulumi.Input[_builtins.bool]]:
+        return pulumi.get(self, "include_minimum")
+
+    @include_minimum.setter
+    def include_minimum(self, value: Optional[pulumi.Input[_builtins.bool]]):
+        pulumi.set(self, "include_minimum", value)
+
+    @_builtins.property
+    @pulumi.getter(name="rangeMaximum")
+    def range_maximum(self) -> Optional[pulumi.Input['DataSetDateFilterValueArgs']]:
+        return pulumi.get(self, "range_maximum")
+
+    @range_maximum.setter
+    def range_maximum(self, value: Optional[pulumi.Input['DataSetDateFilterValueArgs']]):
+        pulumi.set(self, "range_maximum", value)
+
+    @_builtins.property
+    @pulumi.getter(name="rangeMinimum")
+    def range_minimum(self) -> Optional[pulumi.Input['DataSetDateFilterValueArgs']]:
+        return pulumi.get(self, "range_minimum")
+
+    @range_minimum.setter
+    def range_minimum(self, value: Optional[pulumi.Input['DataSetDateFilterValueArgs']]):
+        pulumi.set(self, "range_minimum", value)
+
+
 if not MYPY:
     class DataSetDateTimeDatasetParameterDefaultValuesArgsDict(TypedDict):
         """
@@ -93426,156 +94241,212 @@ class DataSetDateTimeDatasetParameterArgs:
 
     @_builtins.property
     @pulumi.getter(name="defaultValues")
-    def default_values(self) -> Optional[pulumi.Input['DataSetDateTimeDatasetParameterDefaultValuesArgs']]:
+    def default_values(self) -> Optional[pulumi.Input['DataSetDateTimeDatasetParameterDefaultValuesArgs']]:
+        """
+        A list of default values for a given date time parameter. This structure only accepts static values.
+        """
+        return pulumi.get(self, "default_values")
+
+    @default_values.setter
+    def default_values(self, value: Optional[pulumi.Input['DataSetDateTimeDatasetParameterDefaultValuesArgs']]):
+        pulumi.set(self, "default_values", value)
+
+    @_builtins.property
+    @pulumi.getter(name="timeGranularity")
+    def time_granularity(self) -> Optional[pulumi.Input['DataSetTimeGranularity']]:
+        """
+        The time granularity of the date time parameter.
+        """
+        return pulumi.get(self, "time_granularity")
+
+    @time_granularity.setter
+    def time_granularity(self, value: Optional[pulumi.Input['DataSetTimeGranularity']]):
+        pulumi.set(self, "time_granularity", value)
+
+
+if not MYPY:
+    class DataSetDecimalDatasetParameterDefaultValuesArgsDict(TypedDict):
+        """
+        <p>The default values of a decimal parameter.</p>
+        """
+        static_values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]
+        """
+        <p>A list of static default values for a given decimal parameter.</p>
+        """
+elif False:
+    DataSetDecimalDatasetParameterDefaultValuesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetDecimalDatasetParameterDefaultValuesArgs:
+    def __init__(__self__, *,
+                 static_values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None):
+        """
+        <p>The default values of a decimal parameter.</p>
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] static_values: <p>A list of static default values for a given decimal 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[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]:
+        """
+        <p>A list of static default values for a given decimal parameter.</p>
+        """
+        return pulumi.get(self, "static_values")
+
+    @static_values.setter
+    def static_values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]):
+        pulumi.set(self, "static_values", value)
+
+
+if not MYPY:
+    class DataSetDecimalDatasetParameterArgsDict(TypedDict):
+        """
+        <p>A decimal parameter for a dataset.</p>
+        """
+        id: pulumi.Input[_builtins.str]
+        """
+        <p>An identifier for the decimal parameter created in the dataset.</p>
+        """
+        name: pulumi.Input[_builtins.str]
+        """
+        <p>The name of the decimal parameter that is created in the dataset.</p>
+        """
+        value_type: pulumi.Input['DataSetDatasetParameterValueType']
+        """
+        The value type of the dataset parameter. Valid values are `single value` or `multi value` .
+        """
+        default_values: NotRequired[pulumi.Input['DataSetDecimalDatasetParameterDefaultValuesArgsDict']]
+        """
+        A list of default values for a given decimal parameter. This structure only accepts static values.
+        """
+elif False:
+    DataSetDecimalDatasetParameterArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetDecimalDatasetParameterArgs:
+    def __init__(__self__, *,
+                 id: pulumi.Input[_builtins.str],
+                 name: pulumi.Input[_builtins.str],
+                 value_type: pulumi.Input['DataSetDatasetParameterValueType'],
+                 default_values: Optional[pulumi.Input['DataSetDecimalDatasetParameterDefaultValuesArgs']] = None):
+        """
+        <p>A decimal parameter for a dataset.</p>
+        :param pulumi.Input[_builtins.str] id: <p>An identifier for the decimal parameter created in the dataset.</p>
+        :param pulumi.Input[_builtins.str] name: <p>The name of the decimal parameter that is created in the dataset.</p>
+        :param pulumi.Input['DataSetDatasetParameterValueType'] value_type: The value type of the dataset parameter. Valid values are `single value` or `multi value` .
+        :param pulumi.Input['DataSetDecimalDatasetParameterDefaultValuesArgs'] default_values: A list of default values for a given decimal parameter. This structure only accepts static values.
+        """
+        pulumi.set(__self__, "id", id)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "value_type", value_type)
+        if default_values is not None:
+            pulumi.set(__self__, "default_values", default_values)
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> pulumi.Input[_builtins.str]:
+        """
+        <p>An identifier for the decimal parameter created in the dataset.</p>
+        """
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "id", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> pulumi.Input[_builtins.str]:
+        """
+        <p>The name of the decimal parameter that is created in the dataset.</p>
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "name", value)
+
+    @_builtins.property
+    @pulumi.getter(name="valueType")
+    def value_type(self) -> pulumi.Input['DataSetDatasetParameterValueType']:
+        """
+        The value type of the dataset parameter. Valid values are `single value` or `multi value` .
+        """
+        return pulumi.get(self, "value_type")
+
+    @value_type.setter
+    def value_type(self, value: pulumi.Input['DataSetDatasetParameterValueType']):
+        pulumi.set(self, "value_type", value)
+
+    @_builtins.property
+    @pulumi.getter(name="defaultValues")
+    def default_values(self) -> Optional[pulumi.Input['DataSetDecimalDatasetParameterDefaultValuesArgs']]:
         """
-        A list of default values for a given date time parameter. This structure only accepts static values.
+        A list of default values for a given decimal parameter. This structure only accepts static values.
         """
         return pulumi.get(self, "default_values")
 
     @default_values.setter
-    def default_values(self, value: Optional[pulumi.Input['DataSetDateTimeDatasetParameterDefaultValuesArgs']]):
+    def default_values(self, value: Optional[pulumi.Input['DataSetDecimalDatasetParameterDefaultValuesArgs']]):
         pulumi.set(self, "default_values", value)
 
-    @_builtins.property
-    @pulumi.getter(name="timeGranularity")
-    def time_granularity(self) -> Optional[pulumi.Input['DataSetTimeGranularity']]:
-        """
-        The time granularity of the date time parameter.
-        """
-        return pulumi.get(self, "time_granularity")
-
-    @time_granularity.setter
-    def time_granularity(self, value: Optional[pulumi.Input['DataSetTimeGranularity']]):
-        pulumi.set(self, "time_granularity", value)
-
 
 if not MYPY:
-    class DataSetDecimalDatasetParameterDefaultValuesArgsDict(TypedDict):
-        """
-        <p>The default values of a decimal parameter.</p>
-        """
-        static_values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]
-        """
-        <p>A list of static default values for a given decimal parameter.</p>
-        """
+    class DataSetDestinationTableSourceArgsDict(TypedDict):
+        transform_operation_id: pulumi.Input[_builtins.str]
 elif False:
-    DataSetDecimalDatasetParameterDefaultValuesArgsDict: TypeAlias = Mapping[str, Any]
+    DataSetDestinationTableSourceArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class DataSetDecimalDatasetParameterDefaultValuesArgs:
+class DataSetDestinationTableSourceArgs:
     def __init__(__self__, *,
-                 static_values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None):
-        """
-        <p>The default values of a decimal parameter.</p>
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] static_values: <p>A list of static default values for a given decimal parameter.</p>
-        """
-        if static_values is not None:
-            pulumi.set(__self__, "static_values", static_values)
+                 transform_operation_id: pulumi.Input[_builtins.str]):
+        pulumi.set(__self__, "transform_operation_id", transform_operation_id)
 
     @_builtins.property
-    @pulumi.getter(name="staticValues")
-    def static_values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]:
-        """
-        <p>A list of static default values for a given decimal parameter.</p>
-        """
-        return pulumi.get(self, "static_values")
+    @pulumi.getter(name="transformOperationId")
+    def transform_operation_id(self) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "transform_operation_id")
 
-    @static_values.setter
-    def static_values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]):
-        pulumi.set(self, "static_values", value)
+    @transform_operation_id.setter
+    def transform_operation_id(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "transform_operation_id", value)
 
 
 if not MYPY:
-    class DataSetDecimalDatasetParameterArgsDict(TypedDict):
-        """
-        <p>A decimal parameter for a dataset.</p>
-        """
-        id: pulumi.Input[_builtins.str]
-        """
-        <p>An identifier for the decimal parameter created in the dataset.</p>
-        """
-        name: pulumi.Input[_builtins.str]
-        """
-        <p>The name of the decimal parameter that is created in the dataset.</p>
-        """
-        value_type: pulumi.Input['DataSetDatasetParameterValueType']
-        """
-        The value type of the dataset parameter. Valid values are `single value` or `multi value` .
-        """
-        default_values: NotRequired[pulumi.Input['DataSetDecimalDatasetParameterDefaultValuesArgsDict']]
-        """
-        A list of default values for a given decimal parameter. This structure only accepts static values.
-        """
+    class DataSetDestinationTableArgsDict(TypedDict):
+        alias: pulumi.Input[_builtins.str]
+        source: pulumi.Input['DataSetDestinationTableSourceArgsDict']
 elif False:
-    DataSetDecimalDatasetParameterArgsDict: TypeAlias = Mapping[str, Any]
+    DataSetDestinationTableArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class DataSetDecimalDatasetParameterArgs:
+class DataSetDestinationTableArgs:
     def __init__(__self__, *,
-                 id: pulumi.Input[_builtins.str],
-                 name: pulumi.Input[_builtins.str],
-                 value_type: pulumi.Input['DataSetDatasetParameterValueType'],
-                 default_values: Optional[pulumi.Input['DataSetDecimalDatasetParameterDefaultValuesArgs']] = None):
-        """
-        <p>A decimal parameter for a dataset.</p>
-        :param pulumi.Input[_builtins.str] id: <p>An identifier for the decimal parameter created in the dataset.</p>
-        :param pulumi.Input[_builtins.str] name: <p>The name of the decimal parameter that is created in the dataset.</p>
-        :param pulumi.Input['DataSetDatasetParameterValueType'] value_type: The value type of the dataset parameter. Valid values are `single value` or `multi value` .
-        :param pulumi.Input['DataSetDecimalDatasetParameterDefaultValuesArgs'] default_values: A list of default values for a given decimal parameter. This structure only accepts static values.
-        """
-        pulumi.set(__self__, "id", id)
-        pulumi.set(__self__, "name", name)
-        pulumi.set(__self__, "value_type", value_type)
-        if default_values is not None:
-            pulumi.set(__self__, "default_values", default_values)
+                 alias: pulumi.Input[_builtins.str],
+                 source: pulumi.Input['DataSetDestinationTableSourceArgs']):
+        pulumi.set(__self__, "alias", alias)
+        pulumi.set(__self__, "source", source)
 
     @_builtins.property
     @pulumi.getter
-    def id(self) -> pulumi.Input[_builtins.str]:
-        """
-        <p>An identifier for the decimal parameter created in the dataset.</p>
-        """
-        return pulumi.get(self, "id")
+    def alias(self) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "alias")
 
-    @id.setter
-    def id(self, value: pulumi.Input[_builtins.str]):
-        pulumi.set(self, "id", value)
+    @alias.setter
+    def alias(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "alias", value)
 
     @_builtins.property
     @pulumi.getter
-    def name(self) -> pulumi.Input[_builtins.str]:
-        """
-        <p>The name of the decimal parameter that is created in the dataset.</p>
-        """
-        return pulumi.get(self, "name")
-
-    @name.setter
-    def name(self, value: pulumi.Input[_builtins.str]):
-        pulumi.set(self, "name", value)
-
-    @_builtins.property
-    @pulumi.getter(name="valueType")
-    def value_type(self) -> pulumi.Input['DataSetDatasetParameterValueType']:
-        """
-        The value type of the dataset parameter. Valid values are `single value` or `multi value` .
-        """
-        return pulumi.get(self, "value_type")
-
-    @value_type.setter
-    def value_type(self, value: pulumi.Input['DataSetDatasetParameterValueType']):
-        pulumi.set(self, "value_type", value)
-
-    @_builtins.property
-    @pulumi.getter(name="defaultValues")
-    def default_values(self) -> Optional[pulumi.Input['DataSetDecimalDatasetParameterDefaultValuesArgs']]:
-        """
-        A list of default values for a given decimal parameter. This structure only accepts static values.
-        """
-        return pulumi.get(self, "default_values")
+    def source(self) -> pulumi.Input['DataSetDestinationTableSourceArgs']:
+        return pulumi.get(self, "source")
 
-    @default_values.setter
-    def default_values(self, value: Optional[pulumi.Input['DataSetDecimalDatasetParameterDefaultValuesArgs']]):
-        pulumi.set(self, "default_values", value)
+    @source.setter
+    def source(self, value: pulumi.Input['DataSetDestinationTableSourceArgs']):
+        pulumi.set(self, "source", value)
 
 
 if not MYPY:
@@ -93644,13 +94515,19 @@ if not MYPY:
         <p>An expression that must evaluate to a Boolean value. Rows for which the expression
                     evaluates to true are kept in the dataset.</p>
         """
+        date_filter_condition: NotRequired[pulumi.Input['DataSetDateFilterConditionArgsDict']]
+        numeric_filter_condition: NotRequired[pulumi.Input['DataSetNumericFilterConditionArgsDict']]
+        string_filter_condition: NotRequired[pulumi.Input['DataSetStringFilterConditionArgsDict']]
 elif False:
     DataSetFilterOperationArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class DataSetFilterOperationArgs:
     def __init__(__self__, *,
-                 condition_expression: Optional[pulumi.Input[_builtins.str]] = None):
+                 condition_expression: Optional[pulumi.Input[_builtins.str]] = None,
+                 date_filter_condition: Optional[pulumi.Input['DataSetDateFilterConditionArgs']] = None,
+                 numeric_filter_condition: Optional[pulumi.Input['DataSetNumericFilterConditionArgs']] = None,
+                 string_filter_condition: Optional[pulumi.Input['DataSetStringFilterConditionArgs']] = None):
         """
         <p>A transform operation that filters rows based on a condition.</p>
         :param pulumi.Input[_builtins.str] condition_expression: <p>An expression that must evaluate to a Boolean value. Rows for which the expression
@@ -93658,6 +94535,12 @@ class DataSetFilterOperationArgs:
         """
         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")
@@ -93672,6 +94555,79 @@ class DataSetFilterOperationArgs:
     def condition_expression(self, value: Optional[pulumi.Input[_builtins.str]]):
         pulumi.set(self, "condition_expression", value)
 
+    @_builtins.property
+    @pulumi.getter(name="dateFilterCondition")
+    def date_filter_condition(self) -> Optional[pulumi.Input['DataSetDateFilterConditionArgs']]:
+        return pulumi.get(self, "date_filter_condition")
+
+    @date_filter_condition.setter
+    def date_filter_condition(self, value: Optional[pulumi.Input['DataSetDateFilterConditionArgs']]):
+        pulumi.set(self, "date_filter_condition", value)
+
+    @_builtins.property
+    @pulumi.getter(name="numericFilterCondition")
+    def numeric_filter_condition(self) -> Optional[pulumi.Input['DataSetNumericFilterConditionArgs']]:
+        return pulumi.get(self, "numeric_filter_condition")
+
+    @numeric_filter_condition.setter
+    def numeric_filter_condition(self, value: Optional[pulumi.Input['DataSetNumericFilterConditionArgs']]):
+        pulumi.set(self, "numeric_filter_condition", value)
+
+    @_builtins.property
+    @pulumi.getter(name="stringFilterCondition")
+    def string_filter_condition(self) -> Optional[pulumi.Input['DataSetStringFilterConditionArgs']]:
+        return pulumi.get(self, "string_filter_condition")
+
+    @string_filter_condition.setter
+    def string_filter_condition(self, value: Optional[pulumi.Input['DataSetStringFilterConditionArgs']]):
+        pulumi.set(self, "string_filter_condition", value)
+
+
+if not MYPY:
+    class DataSetFiltersOperationArgsDict(TypedDict):
+        alias: pulumi.Input[_builtins.str]
+        filter_operations: pulumi.Input[Sequence[pulumi.Input['DataSetFilterOperationArgsDict']]]
+        source: pulumi.Input['DataSetTransformOperationSourceArgsDict']
+elif False:
+    DataSetFiltersOperationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetFiltersOperationArgs:
+    def __init__(__self__, *,
+                 alias: pulumi.Input[_builtins.str],
+                 filter_operations: pulumi.Input[Sequence[pulumi.Input['DataSetFilterOperationArgs']]],
+                 source: pulumi.Input['DataSetTransformOperationSourceArgs']):
+        pulumi.set(__self__, "alias", alias)
+        pulumi.set(__self__, "filter_operations", filter_operations)
+        pulumi.set(__self__, "source", source)
+
+    @_builtins.property
+    @pulumi.getter
+    def alias(self) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "alias")
+
+    @alias.setter
+    def alias(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "alias", value)
+
+    @_builtins.property
+    @pulumi.getter(name="filterOperations")
+    def filter_operations(self) -> pulumi.Input[Sequence[pulumi.Input['DataSetFilterOperationArgs']]]:
+        return pulumi.get(self, "filter_operations")
+
+    @filter_operations.setter
+    def filter_operations(self, value: pulumi.Input[Sequence[pulumi.Input['DataSetFilterOperationArgs']]]):
+        pulumi.set(self, "filter_operations", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def source(self) -> pulumi.Input['DataSetTransformOperationSourceArgs']:
+        return pulumi.get(self, "source")
+
+    @source.setter
+    def source(self, value: pulumi.Input['DataSetTransformOperationSourceArgs']):
+        pulumi.set(self, "source", value)
+
 
 if not MYPY:
     class DataSetGeoSpatialColumnGroupArgsDict(TypedDict):
@@ -93747,6 +94703,75 @@ class DataSetGeoSpatialColumnGroupArgs:
         pulumi.set(self, "country_code", value)
 
 
+if not MYPY:
+    class DataSetImportTableOperationSourceArgsDict(TypedDict):
+        source_table_id: pulumi.Input[_builtins.str]
+        column_id_mappings: NotRequired[pulumi.Input[Sequence[pulumi.Input['DataSetColumnIdMappingArgsDict']]]]
+elif False:
+    DataSetImportTableOperationSourceArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetImportTableOperationSourceArgs:
+    def __init__(__self__, *,
+                 source_table_id: pulumi.Input[_builtins.str],
+                 column_id_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['DataSetColumnIdMappingArgs']]]] = 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) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "source_table_id")
+
+    @source_table_id.setter
+    def source_table_id(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "source_table_id", value)
+
+    @_builtins.property
+    @pulumi.getter(name="columnIdMappings")
+    def column_id_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataSetColumnIdMappingArgs']]]]:
+        return pulumi.get(self, "column_id_mappings")
+
+    @column_id_mappings.setter
+    def column_id_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataSetColumnIdMappingArgs']]]]):
+        pulumi.set(self, "column_id_mappings", value)
+
+
+if not MYPY:
+    class DataSetImportTableOperationArgsDict(TypedDict):
+        alias: pulumi.Input[_builtins.str]
+        source: pulumi.Input['DataSetImportTableOperationSourceArgsDict']
+elif False:
+    DataSetImportTableOperationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetImportTableOperationArgs:
+    def __init__(__self__, *,
+                 alias: pulumi.Input[_builtins.str],
+                 source: pulumi.Input['DataSetImportTableOperationSourceArgs']):
+        pulumi.set(__self__, "alias", alias)
+        pulumi.set(__self__, "source", source)
+
+    @_builtins.property
+    @pulumi.getter
+    def alias(self) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "alias")
+
+    @alias.setter
+    def alias(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "alias", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def source(self) -> pulumi.Input['DataSetImportTableOperationSourceArgs']:
+        return pulumi.get(self, "source")
+
+    @source.setter
+    def source(self, value: pulumi.Input['DataSetImportTableOperationSourceArgs']):
+        pulumi.set(self, "source", value)
+
+
 if not MYPY:
     class DataSetIncrementalRefreshArgsDict(TypedDict):
         """
@@ -93857,6 +94882,7 @@ if not MYPY:
         """
         The data type of the column.
         """
+        id: NotRequired[pulumi.Input[_builtins.str]]
         sub_type: NotRequired[pulumi.Input['DataSetColumnDataSubType']]
         """
         The sub data type of the column. Sub types are only available for decimal columns that are part of a SPICE dataset.
@@ -93869,6 +94895,7 @@ class DataSetInputColumnArgs:
     def __init__(__self__, *,
                  name: pulumi.Input[_builtins.str],
                  type: pulumi.Input['DataSetInputColumnDataType'],
+                 id: Optional[pulumi.Input[_builtins.str]] = None,
                  sub_type: Optional[pulumi.Input['DataSetColumnDataSubType']] = None):
         """
         <p>Metadata for a column that is used as the input of a transform operation.</p>
@@ -93878,6 +94905,8 @@ class DataSetInputColumnArgs:
         """
         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)
 
@@ -93905,6 +94934,15 @@ class DataSetInputColumnArgs:
     def type(self, value: pulumi.Input['DataSetInputColumnDataType']):
         pulumi.set(self, "type", value)
 
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> Optional[pulumi.Input[_builtins.str]]:
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "id", value)
+
     @_builtins.property
     @pulumi.getter(name="subType")
     def sub_type(self) -> Optional[pulumi.Input['DataSetColumnDataSubType']]:
@@ -93923,7 +94961,7 @@ if not MYPY:
         """
         <p>The default values of an integer parameter.</p>
         """
-        static_values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]
+        static_values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]
         """
         <p>A list of static default values for a given integer parameter.</p>
         """
@@ -93933,24 +94971,24 @@ elif False:
 @pulumi.input_type
 class DataSetIntegerDatasetParameterDefaultValuesArgs:
     def __init__(__self__, *,
-                 static_values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None):
+                 static_values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]] = None):
         """
         <p>The default values of an integer parameter.</p>
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] static_values: <p>A list of static default values for a given integer parameter.</p>
+        :param pulumi.Input[Sequence[pulumi.Input[_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[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]:
+    def static_values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]:
         """
         <p>A list of static default values for a given integer parameter.</p>
         """
         return pulumi.get(self, "static_values")
 
     @static_values.setter
-    def static_values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]):
+    def static_values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]):
         pulumi.set(self, "static_values", value)
 
 
@@ -94218,6 +95256,124 @@ class DataSetJoinKeyPropertiesArgs:
         pulumi.set(self, "unique_key", value)
 
 
+if not MYPY:
+    class DataSetJoinOperandPropertiesArgsDict(TypedDict):
+        output_column_name_overrides: pulumi.Input[Sequence[pulumi.Input['DataSetOutputColumnNameOverrideArgsDict']]]
+elif False:
+    DataSetJoinOperandPropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetJoinOperandPropertiesArgs:
+    def __init__(__self__, *,
+                 output_column_name_overrides: pulumi.Input[Sequence[pulumi.Input['DataSetOutputColumnNameOverrideArgs']]]):
+        pulumi.set(__self__, "output_column_name_overrides", output_column_name_overrides)
+
+    @_builtins.property
+    @pulumi.getter(name="outputColumnNameOverrides")
+    def output_column_name_overrides(self) -> pulumi.Input[Sequence[pulumi.Input['DataSetOutputColumnNameOverrideArgs']]]:
+        return pulumi.get(self, "output_column_name_overrides")
+
+    @output_column_name_overrides.setter
+    def output_column_name_overrides(self, value: pulumi.Input[Sequence[pulumi.Input['DataSetOutputColumnNameOverrideArgs']]]):
+        pulumi.set(self, "output_column_name_overrides", value)
+
+
+if not MYPY:
+    class DataSetJoinOperationArgsDict(TypedDict):
+        alias: pulumi.Input[_builtins.str]
+        left_operand: pulumi.Input['DataSetTransformOperationSourceArgsDict']
+        on_clause: pulumi.Input[_builtins.str]
+        right_operand: pulumi.Input['DataSetTransformOperationSourceArgsDict']
+        type: pulumi.Input['DataSetJoinOperationType']
+        left_operand_properties: NotRequired[pulumi.Input['DataSetJoinOperandPropertiesArgsDict']]
+        right_operand_properties: NotRequired[pulumi.Input['DataSetJoinOperandPropertiesArgsDict']]
+elif False:
+    DataSetJoinOperationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetJoinOperationArgs:
+    def __init__(__self__, *,
+                 alias: pulumi.Input[_builtins.str],
+                 left_operand: pulumi.Input['DataSetTransformOperationSourceArgs'],
+                 on_clause: pulumi.Input[_builtins.str],
+                 right_operand: pulumi.Input['DataSetTransformOperationSourceArgs'],
+                 type: pulumi.Input['DataSetJoinOperationType'],
+                 left_operand_properties: Optional[pulumi.Input['DataSetJoinOperandPropertiesArgs']] = None,
+                 right_operand_properties: Optional[pulumi.Input['DataSetJoinOperandPropertiesArgs']] = 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) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "alias")
+
+    @alias.setter
+    def alias(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "alias", value)
+
+    @_builtins.property
+    @pulumi.getter(name="leftOperand")
+    def left_operand(self) -> pulumi.Input['DataSetTransformOperationSourceArgs']:
+        return pulumi.get(self, "left_operand")
+
+    @left_operand.setter
+    def left_operand(self, value: pulumi.Input['DataSetTransformOperationSourceArgs']):
+        pulumi.set(self, "left_operand", value)
+
+    @_builtins.property
+    @pulumi.getter(name="onClause")
+    def on_clause(self) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "on_clause")
+
+    @on_clause.setter
+    def on_clause(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "on_clause", value)
+
+    @_builtins.property
+    @pulumi.getter(name="rightOperand")
+    def right_operand(self) -> pulumi.Input['DataSetTransformOperationSourceArgs']:
+        return pulumi.get(self, "right_operand")
+
+    @right_operand.setter
+    def right_operand(self, value: pulumi.Input['DataSetTransformOperationSourceArgs']):
+        pulumi.set(self, "right_operand", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def type(self) -> pulumi.Input['DataSetJoinOperationType']:
+        return pulumi.get(self, "type")
+
+    @type.setter
+    def type(self, value: pulumi.Input['DataSetJoinOperationType']):
+        pulumi.set(self, "type", value)
+
+    @_builtins.property
+    @pulumi.getter(name="leftOperandProperties")
+    def left_operand_properties(self) -> Optional[pulumi.Input['DataSetJoinOperandPropertiesArgs']]:
+        return pulumi.get(self, "left_operand_properties")
+
+    @left_operand_properties.setter
+    def left_operand_properties(self, value: Optional[pulumi.Input['DataSetJoinOperandPropertiesArgs']]):
+        pulumi.set(self, "left_operand_properties", value)
+
+    @_builtins.property
+    @pulumi.getter(name="rightOperandProperties")
+    def right_operand_properties(self) -> Optional[pulumi.Input['DataSetJoinOperandPropertiesArgs']]:
+        return pulumi.get(self, "right_operand_properties")
+
+    @right_operand_properties.setter
+    def right_operand_properties(self, value: Optional[pulumi.Input['DataSetJoinOperandPropertiesArgs']]):
+        pulumi.set(self, "right_operand_properties", value)
+
+
 if not MYPY:
     class DataSetLogicalTableSourceArgsDict(TypedDict):
         """
@@ -94308,14 +95464,11 @@ if not MYPY:
         """
         <p>A display name for the logical table.</p>
         """
+        source: pulumi.Input['DataSetLogicalTableSourceArgsDict']
         data_transforms: NotRequired[pulumi.Input[Sequence[pulumi.Input['DataSetTransformOperationArgsDict']]]]
         """
         <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>
         """
-        source: NotRequired[pulumi.Input['DataSetLogicalTableSourceArgsDict']]
-        """
-        Source of this logical table.
-        """
 elif False:
     DataSetLogicalTableArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -94323,8 +95476,8 @@ elif False:
 class DataSetLogicalTableArgs:
     def __init__(__self__, *,
                  alias: pulumi.Input[_builtins.str],
-                 data_transforms: Optional[pulumi.Input[Sequence[pulumi.Input['DataSetTransformOperationArgs']]]] = None,
-                 source: Optional[pulumi.Input['DataSetLogicalTableSourceArgs']] = None):
+                 source: pulumi.Input['DataSetLogicalTableSourceArgs'],
+                 data_transforms: Optional[pulumi.Input[Sequence[pulumi.Input['DataSetTransformOperationArgs']]]] = 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
@@ -94332,13 +95485,11 @@ class DataSetLogicalTableArgs:
                     table acts as a mutable copy of that physical table through transform operations.</p>
         :param pulumi.Input[_builtins.str] alias: <p>A display name for the logical table.</p>
         :param pulumi.Input[Sequence[pulumi.Input['DataSetTransformOperationArgs']]] 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 pulumi.Input['DataSetLogicalTableSourceArgs'] 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
@@ -94352,6 +95503,15 @@ class DataSetLogicalTableArgs:
     def alias(self, value: pulumi.Input[_builtins.str]):
         pulumi.set(self, "alias", value)
 
+    @_builtins.property
+    @pulumi.getter
+    def source(self) -> pulumi.Input['DataSetLogicalTableSourceArgs']:
+        return pulumi.get(self, "source")
+
+    @source.setter
+    def source(self, value: pulumi.Input['DataSetLogicalTableSourceArgs']):
+        pulumi.set(self, "source", value)
+
     @_builtins.property
     @pulumi.getter(name="dataTransforms")
     def data_transforms(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataSetTransformOperationArgs']]]]:
@@ -94364,18 +95524,6 @@ class DataSetLogicalTableArgs:
     def data_transforms(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataSetTransformOperationArgs']]]]):
         pulumi.set(self, "data_transforms", value)
 
-    @_builtins.property
-    @pulumi.getter
-    def source(self) -> Optional[pulumi.Input['DataSetLogicalTableSourceArgs']]:
-        """
-        Source of this logical table.
-        """
-        return pulumi.get(self, "source")
-
-    @source.setter
-    def source(self, value: Optional[pulumi.Input['DataSetLogicalTableSourceArgs']]):
-        pulumi.set(self, "source", value)
-
 
 if not MYPY:
     class DataSetLookbackWindowArgsDict(TypedDict):
@@ -94463,7 +95611,7 @@ if not MYPY:
         """
         <p>A list of static default values for a given decimal parameter.</p>
         """
-        integer_static_values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]
+        integer_static_values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]
         """
         <p>A list of static default values for a given integer parameter.</p>
         """
@@ -94479,13 +95627,13 @@ class DataSetNewDefaultValuesArgs:
     def __init__(__self__, *,
                  date_time_static_values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                  decimal_static_values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None,
-                 integer_static_values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None,
+                 integer_static_values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]] = None,
                  string_static_values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
         """
         <p>The configuration that overrides the existing default values for a dataset parameter that is inherited from another dataset.</p>
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] date_time_static_values: <p>A list of static default values for a given date time parameter.</p>
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] decimal_static_values: <p>A list of static default values for a given decimal parameter.</p>
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] integer_static_values: <p>A list of static default values for a given integer parameter.</p>
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.int]]] integer_static_values: <p>A list of static default values for a given integer parameter.</p>
         :param pulumi.Input[Sequence[pulumi.Input[_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:
@@ -94523,14 +95671,14 @@ class DataSetNewDefaultValuesArgs:
 
     @_builtins.property
     @pulumi.getter(name="integerStaticValues")
-    def integer_static_values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]:
+    def integer_static_values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]:
         """
         <p>A list of static default values for a given integer parameter.</p>
         """
         return pulumi.get(self, "integer_static_values")
 
     @integer_static_values.setter
-    def integer_static_values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]):
+    def integer_static_values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]):
         pulumi.set(self, "integer_static_values", value)
 
     @_builtins.property
@@ -94546,6 +95694,210 @@ class DataSetNewDefaultValuesArgs:
         pulumi.set(self, "string_static_values", value)
 
 
+if not MYPY:
+    class DataSetNumericComparisonFilterConditionArgsDict(TypedDict):
+        operator: pulumi.Input['DataSetNumericComparisonFilterOperator']
+        value: NotRequired[pulumi.Input['DataSetNumericFilterValueArgsDict']]
+elif False:
+    DataSetNumericComparisonFilterConditionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetNumericComparisonFilterConditionArgs:
+    def __init__(__self__, *,
+                 operator: pulumi.Input['DataSetNumericComparisonFilterOperator'],
+                 value: Optional[pulumi.Input['DataSetNumericFilterValueArgs']] = None):
+        pulumi.set(__self__, "operator", operator)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def operator(self) -> pulumi.Input['DataSetNumericComparisonFilterOperator']:
+        return pulumi.get(self, "operator")
+
+    @operator.setter
+    def operator(self, value: pulumi.Input['DataSetNumericComparisonFilterOperator']):
+        pulumi.set(self, "operator", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def value(self) -> Optional[pulumi.Input['DataSetNumericFilterValueArgs']]:
+        return pulumi.get(self, "value")
+
+    @value.setter
+    def value(self, value: Optional[pulumi.Input['DataSetNumericFilterValueArgs']]):
+        pulumi.set(self, "value", value)
+
+
+if not MYPY:
+    class DataSetNumericFilterConditionArgsDict(TypedDict):
+        column_name: NotRequired[pulumi.Input[_builtins.str]]
+        comparison_filter_condition: NotRequired[pulumi.Input['DataSetNumericComparisonFilterConditionArgsDict']]
+        range_filter_condition: NotRequired[pulumi.Input['DataSetNumericRangeFilterConditionArgsDict']]
+elif False:
+    DataSetNumericFilterConditionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetNumericFilterConditionArgs:
+    def __init__(__self__, *,
+                 column_name: Optional[pulumi.Input[_builtins.str]] = None,
+                 comparison_filter_condition: Optional[pulumi.Input['DataSetNumericComparisonFilterConditionArgs']] = None,
+                 range_filter_condition: Optional[pulumi.Input['DataSetNumericRangeFilterConditionArgs']] = 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[pulumi.Input[_builtins.str]]:
+        return pulumi.get(self, "column_name")
+
+    @column_name.setter
+    def column_name(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "column_name", value)
+
+    @_builtins.property
+    @pulumi.getter(name="comparisonFilterCondition")
+    def comparison_filter_condition(self) -> Optional[pulumi.Input['DataSetNumericComparisonFilterConditionArgs']]:
+        return pulumi.get(self, "comparison_filter_condition")
+
+    @comparison_filter_condition.setter
+    def comparison_filter_condition(self, value: Optional[pulumi.Input['DataSetNumericComparisonFilterConditionArgs']]):
+        pulumi.set(self, "comparison_filter_condition", value)
+
+    @_builtins.property
+    @pulumi.getter(name="rangeFilterCondition")
+    def range_filter_condition(self) -> Optional[pulumi.Input['DataSetNumericRangeFilterConditionArgs']]:
+        return pulumi.get(self, "range_filter_condition")
+
+    @range_filter_condition.setter
+    def range_filter_condition(self, value: Optional[pulumi.Input['DataSetNumericRangeFilterConditionArgs']]):
+        pulumi.set(self, "range_filter_condition", value)
+
+
+if not MYPY:
+    class DataSetNumericFilterValueArgsDict(TypedDict):
+        static_value: NotRequired[pulumi.Input[_builtins.float]]
+elif False:
+    DataSetNumericFilterValueArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetNumericFilterValueArgs:
+    def __init__(__self__, *,
+                 static_value: Optional[pulumi.Input[_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[pulumi.Input[_builtins.float]]:
+        return pulumi.get(self, "static_value")
+
+    @static_value.setter
+    def static_value(self, value: Optional[pulumi.Input[_builtins.float]]):
+        pulumi.set(self, "static_value", value)
+
+
+if not MYPY:
+    class DataSetNumericRangeFilterConditionArgsDict(TypedDict):
+        include_maximum: NotRequired[pulumi.Input[_builtins.bool]]
+        include_minimum: NotRequired[pulumi.Input[_builtins.bool]]
+        range_maximum: NotRequired[pulumi.Input['DataSetNumericFilterValueArgsDict']]
+        range_minimum: NotRequired[pulumi.Input['DataSetNumericFilterValueArgsDict']]
+elif False:
+    DataSetNumericRangeFilterConditionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetNumericRangeFilterConditionArgs:
+    def __init__(__self__, *,
+                 include_maximum: Optional[pulumi.Input[_builtins.bool]] = None,
+                 include_minimum: Optional[pulumi.Input[_builtins.bool]] = None,
+                 range_maximum: Optional[pulumi.Input['DataSetNumericFilterValueArgs']] = None,
+                 range_minimum: Optional[pulumi.Input['DataSetNumericFilterValueArgs']] = 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[pulumi.Input[_builtins.bool]]:
+        return pulumi.get(self, "include_maximum")
+
+    @include_maximum.setter
+    def include_maximum(self, value: Optional[pulumi.Input[_builtins.bool]]):
+        pulumi.set(self, "include_maximum", value)
+
+    @_builtins.property
+    @pulumi.getter(name="includeMinimum")
+    def include_minimum(self) -> Optional[pulumi.Input[_builtins.bool]]:
+        return pulumi.get(self, "include_minimum")
+
+    @include_minimum.setter
+    def include_minimum(self, value: Optional[pulumi.Input[_builtins.bool]]):
+        pulumi.set(self, "include_minimum", value)
+
+    @_builtins.property
+    @pulumi.getter(name="rangeMaximum")
+    def range_maximum(self) -> Optional[pulumi.Input['DataSetNumericFilterValueArgs']]:
+        return pulumi.get(self, "range_maximum")
+
+    @range_maximum.setter
+    def range_maximum(self, value: Optional[pulumi.Input['DataSetNumericFilterValueArgs']]):
+        pulumi.set(self, "range_maximum", value)
+
+    @_builtins.property
+    @pulumi.getter(name="rangeMinimum")
+    def range_minimum(self) -> Optional[pulumi.Input['DataSetNumericFilterValueArgs']]:
+        return pulumi.get(self, "range_minimum")
+
+    @range_minimum.setter
+    def range_minimum(self, value: Optional[pulumi.Input['DataSetNumericFilterValueArgs']]):
+        pulumi.set(self, "range_minimum", value)
+
+
+if not MYPY:
+    class DataSetOutputColumnNameOverrideArgsDict(TypedDict):
+        output_column_name: pulumi.Input[_builtins.str]
+        source_column_name: NotRequired[pulumi.Input[_builtins.str]]
+elif False:
+    DataSetOutputColumnNameOverrideArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetOutputColumnNameOverrideArgs:
+    def __init__(__self__, *,
+                 output_column_name: pulumi.Input[_builtins.str],
+                 source_column_name: Optional[pulumi.Input[_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) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "output_column_name")
+
+    @output_column_name.setter
+    def output_column_name(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "output_column_name", value)
+
+    @_builtins.property
+    @pulumi.getter(name="sourceColumnName")
+    def source_column_name(self) -> Optional[pulumi.Input[_builtins.str]]:
+        return pulumi.get(self, "source_column_name")
+
+    @source_column_name.setter
+    def source_column_name(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "source_column_name", value)
+
+
 if not MYPY:
     class DataSetOverrideDatasetParameterOperationArgsDict(TypedDict):
         """
@@ -94621,6 +95973,40 @@ class DataSetOverrideDatasetParameterOperationArgs:
         pulumi.set(self, "new_parameter_name", value)
 
 
+if not MYPY:
+    class DataSetParentDataSetArgsDict(TypedDict):
+        data_set_arn: pulumi.Input[_builtins.str]
+        input_columns: pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgsDict']]]
+elif False:
+    DataSetParentDataSetArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetParentDataSetArgs:
+    def __init__(__self__, *,
+                 data_set_arn: pulumi.Input[_builtins.str],
+                 input_columns: pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]]):
+        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) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "data_set_arn")
+
+    @data_set_arn.setter
+    def data_set_arn(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "data_set_arn", value)
+
+    @_builtins.property
+    @pulumi.getter(name="inputColumns")
+    def input_columns(self) -> pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]]:
+        return pulumi.get(self, "input_columns")
+
+    @input_columns.setter
+    def input_columns(self, value: pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]]):
+        pulumi.set(self, "input_columns", value)
+
+
 if not MYPY:
     class DataSetPerformanceConfigurationArgsDict(TypedDict):
         unique_keys: NotRequired[pulumi.Input[Sequence[pulumi.Input['DataSetUniqueKeyArgsDict']]]]
@@ -94663,6 +96049,7 @@ if not MYPY:
         """
         A physical table type for as S3 data source.
         """
+        saa_s_table: NotRequired[pulumi.Input['DataSetSaaSTableArgsDict']]
 elif False:
     DataSetPhysicalTableArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -94671,7 +96058,8 @@ class DataSetPhysicalTableArgs:
     def __init__(__self__, *,
                  custom_sql: Optional[pulumi.Input['DataSetCustomSqlArgs']] = None,
                  relational_table: Optional[pulumi.Input['DataSetRelationalTableArgs']] = None,
-                 s3_source: Optional[pulumi.Input['DataSetS3SourceArgs']] = None):
+                 s3_source: Optional[pulumi.Input['DataSetS3SourceArgs']] = None,
+                 saa_s_table: Optional[pulumi.Input['DataSetSaaSTableArgs']] = 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,
@@ -94686,6 +96074,8 @@ class DataSetPhysicalTableArgs:
             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")
@@ -94723,6 +96113,167 @@ class DataSetPhysicalTableArgs:
     def s3_source(self, value: Optional[pulumi.Input['DataSetS3SourceArgs']]):
         pulumi.set(self, "s3_source", value)
 
+    @_builtins.property
+    @pulumi.getter(name="saaSTable")
+    def saa_s_table(self) -> Optional[pulumi.Input['DataSetSaaSTableArgs']]:
+        return pulumi.get(self, "saa_s_table")
+
+    @saa_s_table.setter
+    def saa_s_table(self, value: Optional[pulumi.Input['DataSetSaaSTableArgs']]):
+        pulumi.set(self, "saa_s_table", value)
+
+
+if not MYPY:
+    class DataSetPivotConfigurationArgsDict(TypedDict):
+        pivoted_labels: pulumi.Input[Sequence[pulumi.Input['DataSetPivotedLabelArgsDict']]]
+        label_column_name: NotRequired[pulumi.Input[_builtins.str]]
+elif False:
+    DataSetPivotConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetPivotConfigurationArgs:
+    def __init__(__self__, *,
+                 pivoted_labels: pulumi.Input[Sequence[pulumi.Input['DataSetPivotedLabelArgs']]],
+                 label_column_name: Optional[pulumi.Input[_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) -> pulumi.Input[Sequence[pulumi.Input['DataSetPivotedLabelArgs']]]:
+        return pulumi.get(self, "pivoted_labels")
+
+    @pivoted_labels.setter
+    def pivoted_labels(self, value: pulumi.Input[Sequence[pulumi.Input['DataSetPivotedLabelArgs']]]):
+        pulumi.set(self, "pivoted_labels", value)
+
+    @_builtins.property
+    @pulumi.getter(name="labelColumnName")
+    def label_column_name(self) -> Optional[pulumi.Input[_builtins.str]]:
+        return pulumi.get(self, "label_column_name")
+
+    @label_column_name.setter
+    def label_column_name(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "label_column_name", value)
+
+
+if not MYPY:
+    class DataSetPivotOperationArgsDict(TypedDict):
+        alias: pulumi.Input[_builtins.str]
+        pivot_configuration: pulumi.Input['DataSetPivotConfigurationArgsDict']
+        source: pulumi.Input['DataSetTransformOperationSourceArgsDict']
+        value_column_configuration: pulumi.Input['DataSetValueColumnConfigurationArgsDict']
+        group_by_column_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
+elif False:
+    DataSetPivotOperationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetPivotOperationArgs:
+    def __init__(__self__, *,
+                 alias: pulumi.Input[_builtins.str],
+                 pivot_configuration: pulumi.Input['DataSetPivotConfigurationArgs'],
+                 source: pulumi.Input['DataSetTransformOperationSourceArgs'],
+                 value_column_configuration: pulumi.Input['DataSetValueColumnConfigurationArgs'],
+                 group_by_column_names: Optional[pulumi.Input[Sequence[pulumi.Input[_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) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "alias")
+
+    @alias.setter
+    def alias(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "alias", value)
+
+    @_builtins.property
+    @pulumi.getter(name="pivotConfiguration")
+    def pivot_configuration(self) -> pulumi.Input['DataSetPivotConfigurationArgs']:
+        return pulumi.get(self, "pivot_configuration")
+
+    @pivot_configuration.setter
+    def pivot_configuration(self, value: pulumi.Input['DataSetPivotConfigurationArgs']):
+        pulumi.set(self, "pivot_configuration", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def source(self) -> pulumi.Input['DataSetTransformOperationSourceArgs']:
+        return pulumi.get(self, "source")
+
+    @source.setter
+    def source(self, value: pulumi.Input['DataSetTransformOperationSourceArgs']):
+        pulumi.set(self, "source", value)
+
+    @_builtins.property
+    @pulumi.getter(name="valueColumnConfiguration")
+    def value_column_configuration(self) -> pulumi.Input['DataSetValueColumnConfigurationArgs']:
+        return pulumi.get(self, "value_column_configuration")
+
+    @value_column_configuration.setter
+    def value_column_configuration(self, value: pulumi.Input['DataSetValueColumnConfigurationArgs']):
+        pulumi.set(self, "value_column_configuration", value)
+
+    @_builtins.property
+    @pulumi.getter(name="groupByColumnNames")
+    def group_by_column_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
+        return pulumi.get(self, "group_by_column_names")
+
+    @group_by_column_names.setter
+    def group_by_column_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
+        pulumi.set(self, "group_by_column_names", value)
+
+
+if not MYPY:
+    class DataSetPivotedLabelArgsDict(TypedDict):
+        label_name: pulumi.Input[_builtins.str]
+        new_column_id: pulumi.Input[_builtins.str]
+        new_column_name: pulumi.Input[_builtins.str]
+elif False:
+    DataSetPivotedLabelArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetPivotedLabelArgs:
+    def __init__(__self__, *,
+                 label_name: pulumi.Input[_builtins.str],
+                 new_column_id: pulumi.Input[_builtins.str],
+                 new_column_name: pulumi.Input[_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) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "label_name")
+
+    @label_name.setter
+    def label_name(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "label_name", value)
+
+    @_builtins.property
+    @pulumi.getter(name="newColumnId")
+    def new_column_id(self) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "new_column_id")
+
+    @new_column_id.setter
+    def new_column_id(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "new_column_id", value)
+
+    @_builtins.property
+    @pulumi.getter(name="newColumnName")
+    def new_column_name(self) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "new_column_name")
+
+    @new_column_name.setter
+    def new_column_name(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "new_column_name", value)
+
 
 if not MYPY:
     class DataSetProjectOperationArgsDict(TypedDict):
@@ -94730,24 +96281,41 @@ if not MYPY:
         <p>A transform operation that projects columns. Operations that come after a projection
                     can only refer to projected columns.</p>
         """
+        alias: NotRequired[pulumi.Input[_builtins.str]]
         projected_columns: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
         """
         <p>Projected columns.</p>
         """
+        source: NotRequired[pulumi.Input['DataSetTransformOperationSourceArgsDict']]
 elif False:
     DataSetProjectOperationArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class DataSetProjectOperationArgs:
     def __init__(__self__, *,
-                 projected_columns: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
+                 alias: Optional[pulumi.Input[_builtins.str]] = None,
+                 projected_columns: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
+                 source: Optional[pulumi.Input['DataSetTransformOperationSourceArgs']] = None):
         """
         <p>A transform operation that projects columns. Operations that come after a projection
                     can only refer to projected columns.</p>
         :param pulumi.Input[Sequence[pulumi.Input[_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[pulumi.Input[_builtins.str]]:
+        return pulumi.get(self, "alias")
+
+    @alias.setter
+    def alias(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "alias", value)
 
     @_builtins.property
     @pulumi.getter(name="projectedColumns")
@@ -94761,6 +96329,15 @@ class DataSetProjectOperationArgs:
     def projected_columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
         pulumi.set(self, "projected_columns", value)
 
+    @_builtins.property
+    @pulumi.getter
+    def source(self) -> Optional[pulumi.Input['DataSetTransformOperationSourceArgs']]:
+        return pulumi.get(self, "source")
+
+    @source.setter
+    def source(self, value: Optional[pulumi.Input['DataSetTransformOperationSourceArgs']]):
+        pulumi.set(self, "source", value)
+
 
 if not MYPY:
     class DataSetRefreshConfigurationArgsDict(TypedDict):
@@ -94926,6 +96503,10 @@ if not MYPY:
         """
         <p>The Amazon Resource Name (ARN) for the data source.</p>
         """
+        input_columns: pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgsDict']]]
+        """
+        <p>The column schema of the table.</p>
+        """
         name: pulumi.Input[_builtins.str]
         """
         <p>The name of the relational table.</p>
@@ -94934,10 +96515,6 @@ if not MYPY:
         """
         <p>The catalog associated with a table.</p>
         """
-        input_columns: NotRequired[pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgsDict']]]]
-        """
-        <p>The column schema of the table.</p>
-        """
         schema: NotRequired[pulumi.Input[_builtins.str]]
         """
         <p>The schema name. This name applies to certain relational database engines.</p>
@@ -94949,24 +96526,23 @@ elif False:
 class DataSetRelationalTableArgs:
     def __init__(__self__, *,
                  data_source_arn: pulumi.Input[_builtins.str],
+                 input_columns: pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]],
                  name: pulumi.Input[_builtins.str],
                  catalog: Optional[pulumi.Input[_builtins.str]] = None,
-                 input_columns: Optional[pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]]] = None,
                  schema: Optional[pulumi.Input[_builtins.str]] = None):
         """
         <p>A physical table type for relational data sources.</p>
         :param pulumi.Input[_builtins.str] data_source_arn: <p>The Amazon Resource Name (ARN) for the data source.</p>
+        :param pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]] input_columns: <p>The column schema of the table.</p>
         :param pulumi.Input[_builtins.str] name: <p>The name of the relational table.</p>
         :param pulumi.Input[_builtins.str] catalog: <p>The catalog associated with a table.</p>
-        :param pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]] input_columns: <p>The column schema of the table.</p>
         :param pulumi.Input[_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)
 
@@ -94982,6 +96558,18 @@ class DataSetRelationalTableArgs:
     def data_source_arn(self, value: pulumi.Input[_builtins.str]):
         pulumi.set(self, "data_source_arn", value)
 
+    @_builtins.property
+    @pulumi.getter(name="inputColumns")
+    def input_columns(self) -> pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]]:
+        """
+        <p>The column schema of the table.</p>
+        """
+        return pulumi.get(self, "input_columns")
+
+    @input_columns.setter
+    def input_columns(self, value: pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]]):
+        pulumi.set(self, "input_columns", value)
+
     @_builtins.property
     @pulumi.getter
     def name(self) -> pulumi.Input[_builtins.str]:
@@ -95006,18 +96594,6 @@ class DataSetRelationalTableArgs:
     def catalog(self, value: Optional[pulumi.Input[_builtins.str]]):
         pulumi.set(self, "catalog", value)
 
-    @_builtins.property
-    @pulumi.getter(name="inputColumns")
-    def input_columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]]]:
-        """
-        <p>The column schema of the table.</p>
-        """
-        return pulumi.get(self, "input_columns")
-
-    @input_columns.setter
-    def input_columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]]]):
-        pulumi.set(self, "input_columns", value)
-
     @_builtins.property
     @pulumi.getter
     def schema(self) -> Optional[pulumi.Input[_builtins.str]]:
@@ -95036,11 +96612,11 @@ if not MYPY:
         """
         <p>A transform operation that renames a column.</p>
         """
-        column_name: NotRequired[pulumi.Input[_builtins.str]]
+        column_name: pulumi.Input[_builtins.str]
         """
         <p>The name of the column to be renamed.</p>
         """
-        new_column_name: NotRequired[pulumi.Input[_builtins.str]]
+        new_column_name: pulumi.Input[_builtins.str]
         """
         <p>The new name for the column.</p>
         """
@@ -95050,43 +96626,87 @@ elif False:
 @pulumi.input_type
 class DataSetRenameColumnOperationArgs:
     def __init__(__self__, *,
-                 column_name: Optional[pulumi.Input[_builtins.str]] = None,
-                 new_column_name: Optional[pulumi.Input[_builtins.str]] = None):
+                 column_name: pulumi.Input[_builtins.str],
+                 new_column_name: pulumi.Input[_builtins.str]):
         """
         <p>A transform operation that renames a column.</p>
         :param pulumi.Input[_builtins.str] column_name: <p>The name of the column to be renamed.</p>
         :param pulumi.Input[_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[pulumi.Input[_builtins.str]]:
+    def column_name(self) -> pulumi.Input[_builtins.str]:
         """
         <p>The name of the column to be renamed.</p>
         """
         return pulumi.get(self, "column_name")
 
     @column_name.setter
-    def column_name(self, value: Optional[pulumi.Input[_builtins.str]]):
+    def column_name(self, value: pulumi.Input[_builtins.str]):
         pulumi.set(self, "column_name", value)
 
     @_builtins.property
     @pulumi.getter(name="newColumnName")
-    def new_column_name(self) -> Optional[pulumi.Input[_builtins.str]]:
+    def new_column_name(self) -> pulumi.Input[_builtins.str]:
         """
         <p>The new name for the column.</p>
         """
         return pulumi.get(self, "new_column_name")
 
     @new_column_name.setter
-    def new_column_name(self, value: Optional[pulumi.Input[_builtins.str]]):
+    def new_column_name(self, value: pulumi.Input[_builtins.str]):
         pulumi.set(self, "new_column_name", value)
 
 
+if not MYPY:
+    class DataSetRenameColumnsOperationArgsDict(TypedDict):
+        alias: pulumi.Input[_builtins.str]
+        rename_column_operations: pulumi.Input[Sequence[pulumi.Input['DataSetRenameColumnOperationArgsDict']]]
+        source: pulumi.Input['DataSetTransformOperationSourceArgsDict']
+elif False:
+    DataSetRenameColumnsOperationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetRenameColumnsOperationArgs:
+    def __init__(__self__, *,
+                 alias: pulumi.Input[_builtins.str],
+                 rename_column_operations: pulumi.Input[Sequence[pulumi.Input['DataSetRenameColumnOperationArgs']]],
+                 source: pulumi.Input['DataSetTransformOperationSourceArgs']):
+        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) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "alias")
+
+    @alias.setter
+    def alias(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "alias", value)
+
+    @_builtins.property
+    @pulumi.getter(name="renameColumnOperations")
+    def rename_column_operations(self) -> pulumi.Input[Sequence[pulumi.Input['DataSetRenameColumnOperationArgs']]]:
+        return pulumi.get(self, "rename_column_operations")
+
+    @rename_column_operations.setter
+    def rename_column_operations(self, value: pulumi.Input[Sequence[pulumi.Input['DataSetRenameColumnOperationArgs']]]):
+        pulumi.set(self, "rename_column_operations", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def source(self) -> pulumi.Input['DataSetTransformOperationSourceArgs']:
+        return pulumi.get(self, "source")
+
+    @source.setter
+    def source(self, value: pulumi.Input['DataSetTransformOperationSourceArgs']):
+        pulumi.set(self, "source", value)
+
+
 if not MYPY:
     class DataSetResourcePermissionArgsDict(TypedDict):
         """
@@ -95183,6 +96803,42 @@ class DataSetResourcePermissionArgs:
         pulumi.set(self, "principal", value)
 
 
+if not MYPY:
+    class DataSetRowLevelPermissionConfigurationArgsDict(TypedDict):
+        row_level_permission_data_set: NotRequired[pulumi.Input['DataSetRowLevelPermissionDataSetArgsDict']]
+        tag_configuration: NotRequired[pulumi.Input['DataSetRowLevelPermissionTagConfigurationArgsDict']]
+elif False:
+    DataSetRowLevelPermissionConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetRowLevelPermissionConfigurationArgs:
+    def __init__(__self__, *,
+                 row_level_permission_data_set: Optional[pulumi.Input['DataSetRowLevelPermissionDataSetArgs']] = None,
+                 tag_configuration: Optional[pulumi.Input['DataSetRowLevelPermissionTagConfigurationArgs']] = 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[pulumi.Input['DataSetRowLevelPermissionDataSetArgs']]:
+        return pulumi.get(self, "row_level_permission_data_set")
+
+    @row_level_permission_data_set.setter
+    def row_level_permission_data_set(self, value: Optional[pulumi.Input['DataSetRowLevelPermissionDataSetArgs']]):
+        pulumi.set(self, "row_level_permission_data_set", value)
+
+    @_builtins.property
+    @pulumi.getter(name="tagConfiguration")
+    def tag_configuration(self) -> Optional[pulumi.Input['DataSetRowLevelPermissionTagConfigurationArgs']]:
+        return pulumi.get(self, "tag_configuration")
+
+    @tag_configuration.setter
+    def tag_configuration(self, value: Optional[pulumi.Input['DataSetRowLevelPermissionTagConfigurationArgs']]):
+        pulumi.set(self, "tag_configuration", value)
+
+
 if not MYPY:
     class DataSetRowLevelPermissionDataSetArgsDict(TypedDict):
         """
@@ -95393,13 +97049,13 @@ if not MYPY:
         """
         <p>A set of rules associated with a tag.</p>
         """
-        tag_key: pulumi.Input[_builtins.str]
+        column_name: pulumi.Input[_builtins.str]
         """
-        <p>The unique key for a tag.</p>
+        <p>The column name that a tag key is assigned to.</p>
         """
-        column_name: NotRequired[pulumi.Input[_builtins.str]]
+        tag_key: pulumi.Input[_builtins.str]
         """
-        <p>The column name that a tag key is assigned to.</p>
+        <p>The unique key for a tag.</p>
         """
         match_all_value: NotRequired[pulumi.Input[_builtins.str]]
         """
@@ -95415,25 +97071,36 @@ elif False:
 @pulumi.input_type
 class DataSetRowLevelPermissionTagRuleArgs:
     def __init__(__self__, *,
+                 column_name: pulumi.Input[_builtins.str],
                  tag_key: pulumi.Input[_builtins.str],
-                 column_name: Optional[pulumi.Input[_builtins.str]] = None,
                  match_all_value: Optional[pulumi.Input[_builtins.str]] = None,
                  tag_multi_value_delimiter: Optional[pulumi.Input[_builtins.str]] = None):
         """
         <p>A set of rules associated with a tag.</p>
-        :param pulumi.Input[_builtins.str] tag_key: <p>The unique key for a tag.</p>
         :param pulumi.Input[_builtins.str] column_name: <p>The column name that a tag key is assigned to.</p>
+        :param pulumi.Input[_builtins.str] tag_key: <p>The unique key for a tag.</p>
         :param pulumi.Input[_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 pulumi.Input[_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="columnName")
+    def column_name(self) -> pulumi.Input[_builtins.str]:
+        """
+        <p>The column name that a tag key is assigned to.</p>
+        """
+        return pulumi.get(self, "column_name")
+
+    @column_name.setter
+    def column_name(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "column_name", value)
+
     @_builtins.property
     @pulumi.getter(name="tagKey")
     def tag_key(self) -> pulumi.Input[_builtins.str]:
@@ -95446,18 +97113,6 @@ class DataSetRowLevelPermissionTagRuleArgs:
     def tag_key(self, value: pulumi.Input[_builtins.str]):
         pulumi.set(self, "tag_key", value)
 
-    @_builtins.property
-    @pulumi.getter(name="columnName")
-    def column_name(self) -> Optional[pulumi.Input[_builtins.str]]:
-        """
-        <p>The column name that a tag key is assigned to.</p>
-        """
-        return pulumi.get(self, "column_name")
-
-    @column_name.setter
-    def column_name(self, value: Optional[pulumi.Input[_builtins.str]]):
-        pulumi.set(self, "column_name", value)
-
     @_builtins.property
     @pulumi.getter(name="matchAllValue")
     def match_all_value(self) -> Optional[pulumi.Input[_builtins.str]]:
@@ -95492,7 +97147,7 @@ if not MYPY:
         """
         <p>The Amazon Resource Name (ARN) for the data source.</p>
         """
-        input_columns: NotRequired[pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgsDict']]]]
+        input_columns: pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgsDict']]]
         """
         <p>A physical table type for an S3 data source.</p>
                  <note>
@@ -95510,7 +97165,7 @@ elif False:
 class DataSetS3SourceArgs:
     def __init__(__self__, *,
                  data_source_arn: pulumi.Input[_builtins.str],
-                 input_columns: Optional[pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]]] = None,
+                 input_columns: pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]],
                  upload_settings: Optional[pulumi.Input['DataSetUploadSettingsArgs']] = None):
         """
         <p>A physical table type for an S3 data source.</p>
@@ -95522,8 +97177,7 @@ class DataSetS3SourceArgs:
         :param pulumi.Input['DataSetUploadSettingsArgs'] 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)
 
@@ -95541,7 +97195,7 @@ class DataSetS3SourceArgs:
 
     @_builtins.property
     @pulumi.getter(name="inputColumns")
-    def input_columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]]]:
+    def input_columns(self) -> pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]]:
         """
         <p>A physical table type for an S3 data source.</p>
                  <note>
@@ -95551,7 +97205,7 @@ class DataSetS3SourceArgs:
         return pulumi.get(self, "input_columns")
 
     @input_columns.setter
-    def input_columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]]]):
+    def input_columns(self, value: pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]]):
         pulumi.set(self, "input_columns", value)
 
     @_builtins.property
@@ -95567,6 +97221,193 @@ class DataSetS3SourceArgs:
         pulumi.set(self, "upload_settings", value)
 
 
+if not MYPY:
+    class DataSetSaaSTableArgsDict(TypedDict):
+        data_source_arn: pulumi.Input[_builtins.str]
+        input_columns: pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgsDict']]]
+        table_path: pulumi.Input[Sequence[pulumi.Input['DataSetTablePathElementArgsDict']]]
+elif False:
+    DataSetSaaSTableArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetSaaSTableArgs:
+    def __init__(__self__, *,
+                 data_source_arn: pulumi.Input[_builtins.str],
+                 input_columns: pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]],
+                 table_path: pulumi.Input[Sequence[pulumi.Input['DataSetTablePathElementArgs']]]):
+        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) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "data_source_arn")
+
+    @data_source_arn.setter
+    def data_source_arn(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "data_source_arn", value)
+
+    @_builtins.property
+    @pulumi.getter(name="inputColumns")
+    def input_columns(self) -> pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]]:
+        return pulumi.get(self, "input_columns")
+
+    @input_columns.setter
+    def input_columns(self, value: pulumi.Input[Sequence[pulumi.Input['DataSetInputColumnArgs']]]):
+        pulumi.set(self, "input_columns", value)
+
+    @_builtins.property
+    @pulumi.getter(name="tablePath")
+    def table_path(self) -> pulumi.Input[Sequence[pulumi.Input['DataSetTablePathElementArgs']]]:
+        return pulumi.get(self, "table_path")
+
+    @table_path.setter
+    def table_path(self, value: pulumi.Input[Sequence[pulumi.Input['DataSetTablePathElementArgs']]]):
+        pulumi.set(self, "table_path", value)
+
+
+if not MYPY:
+    class DataSetSemanticModelConfigurationArgsDict(TypedDict):
+        table_map: NotRequired[pulumi.Input[Mapping[str, pulumi.Input['DataSetSemanticTableArgsDict']]]]
+elif False:
+    DataSetSemanticModelConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetSemanticModelConfigurationArgs:
+    def __init__(__self__, *,
+                 table_map: Optional[pulumi.Input[Mapping[str, pulumi.Input['DataSetSemanticTableArgs']]]] = 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[pulumi.Input[Mapping[str, pulumi.Input['DataSetSemanticTableArgs']]]]:
+        return pulumi.get(self, "table_map")
+
+    @table_map.setter
+    def table_map(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input['DataSetSemanticTableArgs']]]]):
+        pulumi.set(self, "table_map", value)
+
+
+if not MYPY:
+    class DataSetSemanticTableArgsDict(TypedDict):
+        alias: pulumi.Input[_builtins.str]
+        destination_table_id: pulumi.Input[_builtins.str]
+        row_level_permission_configuration: NotRequired[pulumi.Input['DataSetRowLevelPermissionConfigurationArgsDict']]
+elif False:
+    DataSetSemanticTableArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetSemanticTableArgs:
+    def __init__(__self__, *,
+                 alias: pulumi.Input[_builtins.str],
+                 destination_table_id: pulumi.Input[_builtins.str],
+                 row_level_permission_configuration: Optional[pulumi.Input['DataSetRowLevelPermissionConfigurationArgs']] = 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) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "alias")
+
+    @alias.setter
+    def alias(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "alias", value)
+
+    @_builtins.property
+    @pulumi.getter(name="destinationTableId")
+    def destination_table_id(self) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "destination_table_id")
+
+    @destination_table_id.setter
+    def destination_table_id(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "destination_table_id", value)
+
+    @_builtins.property
+    @pulumi.getter(name="rowLevelPermissionConfiguration")
+    def row_level_permission_configuration(self) -> Optional[pulumi.Input['DataSetRowLevelPermissionConfigurationArgs']]:
+        return pulumi.get(self, "row_level_permission_configuration")
+
+    @row_level_permission_configuration.setter
+    def row_level_permission_configuration(self, value: Optional[pulumi.Input['DataSetRowLevelPermissionConfigurationArgs']]):
+        pulumi.set(self, "row_level_permission_configuration", value)
+
+
+if not MYPY:
+    class DataSetSourceTableArgsDict(TypedDict):
+        data_set: NotRequired[pulumi.Input['DataSetParentDataSetArgsDict']]
+        physical_table_id: NotRequired[pulumi.Input[_builtins.str]]
+elif False:
+    DataSetSourceTableArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetSourceTableArgs:
+    def __init__(__self__, *,
+                 data_set: Optional[pulumi.Input['DataSetParentDataSetArgs']] = None,
+                 physical_table_id: Optional[pulumi.Input[_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[pulumi.Input['DataSetParentDataSetArgs']]:
+        return pulumi.get(self, "data_set")
+
+    @data_set.setter
+    def data_set(self, value: Optional[pulumi.Input['DataSetParentDataSetArgs']]):
+        pulumi.set(self, "data_set", value)
+
+    @_builtins.property
+    @pulumi.getter(name="physicalTableId")
+    def physical_table_id(self) -> Optional[pulumi.Input[_builtins.str]]:
+        return pulumi.get(self, "physical_table_id")
+
+    @physical_table_id.setter
+    def physical_table_id(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "physical_table_id", value)
+
+
+if not MYPY:
+    class DataSetStringComparisonFilterConditionArgsDict(TypedDict):
+        operator: pulumi.Input['DataSetStringComparisonFilterOperator']
+        value: NotRequired[pulumi.Input['DataSetStringFilterValueArgsDict']]
+elif False:
+    DataSetStringComparisonFilterConditionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetStringComparisonFilterConditionArgs:
+    def __init__(__self__, *,
+                 operator: pulumi.Input['DataSetStringComparisonFilterOperator'],
+                 value: Optional[pulumi.Input['DataSetStringFilterValueArgs']] = None):
+        pulumi.set(__self__, "operator", operator)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def operator(self) -> pulumi.Input['DataSetStringComparisonFilterOperator']:
+        return pulumi.get(self, "operator")
+
+    @operator.setter
+    def operator(self, value: pulumi.Input['DataSetStringComparisonFilterOperator']):
+        pulumi.set(self, "operator", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def value(self) -> Optional[pulumi.Input['DataSetStringFilterValueArgs']]:
+        return pulumi.get(self, "value")
+
+    @value.setter
+    def value(self, value: Optional[pulumi.Input['DataSetStringFilterValueArgs']]):
+        pulumi.set(self, "value", value)
+
+
 if not MYPY:
     class DataSetStringDatasetParameterDefaultValuesArgsDict(TypedDict):
         """
@@ -95696,6 +97537,172 @@ class DataSetStringDatasetParameterArgs:
         pulumi.set(self, "default_values", value)
 
 
+if not MYPY:
+    class DataSetStringFilterConditionArgsDict(TypedDict):
+        column_name: NotRequired[pulumi.Input[_builtins.str]]
+        comparison_filter_condition: NotRequired[pulumi.Input['DataSetStringComparisonFilterConditionArgsDict']]
+        list_filter_condition: NotRequired[pulumi.Input['DataSetStringListFilterConditionArgsDict']]
+elif False:
+    DataSetStringFilterConditionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetStringFilterConditionArgs:
+    def __init__(__self__, *,
+                 column_name: Optional[pulumi.Input[_builtins.str]] = None,
+                 comparison_filter_condition: Optional[pulumi.Input['DataSetStringComparisonFilterConditionArgs']] = None,
+                 list_filter_condition: Optional[pulumi.Input['DataSetStringListFilterConditionArgs']] = 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[pulumi.Input[_builtins.str]]:
+        return pulumi.get(self, "column_name")
+
+    @column_name.setter
+    def column_name(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "column_name", value)
+
+    @_builtins.property
+    @pulumi.getter(name="comparisonFilterCondition")
+    def comparison_filter_condition(self) -> Optional[pulumi.Input['DataSetStringComparisonFilterConditionArgs']]:
+        return pulumi.get(self, "comparison_filter_condition")
+
+    @comparison_filter_condition.setter
+    def comparison_filter_condition(self, value: Optional[pulumi.Input['DataSetStringComparisonFilterConditionArgs']]):
+        pulumi.set(self, "comparison_filter_condition", value)
+
+    @_builtins.property
+    @pulumi.getter(name="listFilterCondition")
+    def list_filter_condition(self) -> Optional[pulumi.Input['DataSetStringListFilterConditionArgs']]:
+        return pulumi.get(self, "list_filter_condition")
+
+    @list_filter_condition.setter
+    def list_filter_condition(self, value: Optional[pulumi.Input['DataSetStringListFilterConditionArgs']]):
+        pulumi.set(self, "list_filter_condition", value)
+
+
+if not MYPY:
+    class DataSetStringFilterValueArgsDict(TypedDict):
+        static_value: NotRequired[pulumi.Input[_builtins.str]]
+elif False:
+    DataSetStringFilterValueArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetStringFilterValueArgs:
+    def __init__(__self__, *,
+                 static_value: Optional[pulumi.Input[_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[pulumi.Input[_builtins.str]]:
+        return pulumi.get(self, "static_value")
+
+    @static_value.setter
+    def static_value(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "static_value", value)
+
+
+if not MYPY:
+    class DataSetStringListFilterConditionArgsDict(TypedDict):
+        operator: pulumi.Input['DataSetStringListFilterOperator']
+        values: NotRequired[pulumi.Input['DataSetStringListFilterValueArgsDict']]
+elif False:
+    DataSetStringListFilterConditionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetStringListFilterConditionArgs:
+    def __init__(__self__, *,
+                 operator: pulumi.Input['DataSetStringListFilterOperator'],
+                 values: Optional[pulumi.Input['DataSetStringListFilterValueArgs']] = None):
+        pulumi.set(__self__, "operator", operator)
+        if values is not None:
+            pulumi.set(__self__, "values", values)
+
+    @_builtins.property
+    @pulumi.getter
+    def operator(self) -> pulumi.Input['DataSetStringListFilterOperator']:
+        return pulumi.get(self, "operator")
+
+    @operator.setter
+    def operator(self, value: pulumi.Input['DataSetStringListFilterOperator']):
+        pulumi.set(self, "operator", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def values(self) -> Optional[pulumi.Input['DataSetStringListFilterValueArgs']]:
+        return pulumi.get(self, "values")
+
+    @values.setter
+    def values(self, value: Optional[pulumi.Input['DataSetStringListFilterValueArgs']]):
+        pulumi.set(self, "values", value)
+
+
+if not MYPY:
+    class DataSetStringListFilterValueArgsDict(TypedDict):
+        static_values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
+elif False:
+    DataSetStringListFilterValueArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetStringListFilterValueArgs:
+    def __init__(__self__, *,
+                 static_values: Optional[pulumi.Input[Sequence[pulumi.Input[_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[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
+        return pulumi.get(self, "static_values")
+
+    @static_values.setter
+    def static_values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
+        pulumi.set(self, "static_values", value)
+
+
+if not MYPY:
+    class DataSetTablePathElementArgsDict(TypedDict):
+        id: NotRequired[pulumi.Input[_builtins.str]]
+        name: NotRequired[pulumi.Input[_builtins.str]]
+elif False:
+    DataSetTablePathElementArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetTablePathElementArgs:
+    def __init__(__self__, *,
+                 id: Optional[pulumi.Input[_builtins.str]] = None,
+                 name: Optional[pulumi.Input[_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[pulumi.Input[_builtins.str]]:
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "id", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> Optional[pulumi.Input[_builtins.str]]:
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "name", value)
+
+
 if not MYPY:
     class DataSetTagColumnOperationArgsDict(TypedDict):
         """
@@ -95759,6 +97766,41 @@ class DataSetTagColumnOperationArgs:
         pulumi.set(self, "tags", value)
 
 
+if not MYPY:
+    class DataSetTransformOperationSourceArgsDict(TypedDict):
+        transform_operation_id: pulumi.Input[_builtins.str]
+        column_id_mappings: NotRequired[pulumi.Input[Sequence[pulumi.Input['DataSetColumnIdMappingArgsDict']]]]
+elif False:
+    DataSetTransformOperationSourceArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetTransformOperationSourceArgs:
+    def __init__(__self__, *,
+                 transform_operation_id: pulumi.Input[_builtins.str],
+                 column_id_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['DataSetColumnIdMappingArgs']]]] = 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) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "transform_operation_id")
+
+    @transform_operation_id.setter
+    def transform_operation_id(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "transform_operation_id", value)
+
+    @_builtins.property
+    @pulumi.getter(name="columnIdMappings")
+    def column_id_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataSetColumnIdMappingArgs']]]]:
+        return pulumi.get(self, "column_id_mappings")
+
+    @column_id_mappings.setter
+    def column_id_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataSetColumnIdMappingArgs']]]]):
+        pulumi.set(self, "column_id_mappings", value)
+
+
 if not MYPY:
     class DataSetTransformOperationArgsDict(TypedDict):
         """
@@ -95930,29 +97972,275 @@ class DataSetTransformOperationArgs:
         pulumi.set(self, "untag_column_operation", value)
 
 
+if not MYPY:
+    class DataSetTransformStepArgsDict(TypedDict):
+        aggregate_step: NotRequired[pulumi.Input['DataSetAggregateOperationArgsDict']]
+        append_step: NotRequired[pulumi.Input['DataSetAppendOperationArgsDict']]
+        cast_column_types_step: NotRequired[pulumi.Input['DataSetCastColumnTypesOperationArgsDict']]
+        create_columns_step: NotRequired[pulumi.Input['DataSetCreateColumnsOperationArgsDict']]
+        filters_step: NotRequired[pulumi.Input['DataSetFiltersOperationArgsDict']]
+        import_table_step: NotRequired[pulumi.Input['DataSetImportTableOperationArgsDict']]
+        join_step: NotRequired[pulumi.Input['DataSetJoinOperationArgsDict']]
+        pivot_step: NotRequired[pulumi.Input['DataSetPivotOperationArgsDict']]
+        project_step: NotRequired[pulumi.Input['DataSetProjectOperationArgsDict']]
+        rename_columns_step: NotRequired[pulumi.Input['DataSetRenameColumnsOperationArgsDict']]
+        unpivot_step: NotRequired[pulumi.Input['DataSetUnpivotOperationArgsDict']]
+elif False:
+    DataSetTransformStepArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetTransformStepArgs:
+    def __init__(__self__, *,
+                 aggregate_step: Optional[pulumi.Input['DataSetAggregateOperationArgs']] = None,
+                 append_step: Optional[pulumi.Input['DataSetAppendOperationArgs']] = None,
+                 cast_column_types_step: Optional[pulumi.Input['DataSetCastColumnTypesOperationArgs']] = None,
+                 create_columns_step: Optional[pulumi.Input['DataSetCreateColumnsOperationArgs']] = None,
+                 filters_step: Optional[pulumi.Input['DataSetFiltersOperationArgs']] = None,
+                 import_table_step: Optional[pulumi.Input['DataSetImportTableOperationArgs']] = None,
+                 join_step: Optional[pulumi.Input['DataSetJoinOperationArgs']] = None,
+                 pivot_step: Optional[pulumi.Input['DataSetPivotOperationArgs']] = None,
+                 project_step: Optional[pulumi.Input['DataSetProjectOperationArgs']] = None,
+                 rename_columns_step: Optional[pulumi.Input['DataSetRenameColumnsOperationArgs']] = None,
+                 unpivot_step: Optional[pulumi.Input['DataSetUnpivotOperationArgs']] = 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[pulumi.Input['DataSetAggregateOperationArgs']]:
+        return pulumi.get(self, "aggregate_step")
+
+    @aggregate_step.setter
+    def aggregate_step(self, value: Optional[pulumi.Input['DataSetAggregateOperationArgs']]):
+        pulumi.set(self, "aggregate_step", value)
+
+    @_builtins.property
+    @pulumi.getter(name="appendStep")
+    def append_step(self) -> Optional[pulumi.Input['DataSetAppendOperationArgs']]:
+        return pulumi.get(self, "append_step")
+
+    @append_step.setter
+    def append_step(self, value: Optional[pulumi.Input['DataSetAppendOperationArgs']]):
+        pulumi.set(self, "append_step", value)
+
+    @_builtins.property
+    @pulumi.getter(name="castColumnTypesStep")
+    def cast_column_types_step(self) -> Optional[pulumi.Input['DataSetCastColumnTypesOperationArgs']]:
+        return pulumi.get(self, "cast_column_types_step")
+
+    @cast_column_types_step.setter
+    def cast_column_types_step(self, value: Optional[pulumi.Input['DataSetCastColumnTypesOperationArgs']]):
+        pulumi.set(self, "cast_column_types_step", value)
+
+    @_builtins.property
+    @pulumi.getter(name="createColumnsStep")
+    def create_columns_step(self) -> Optional[pulumi.Input['DataSetCreateColumnsOperationArgs']]:
+        return pulumi.get(self, "create_columns_step")
+
+    @create_columns_step.setter
+    def create_columns_step(self, value: Optional[pulumi.Input['DataSetCreateColumnsOperationArgs']]):
+        pulumi.set(self, "create_columns_step", value)
+
+    @_builtins.property
+    @pulumi.getter(name="filtersStep")
+    def filters_step(self) -> Optional[pulumi.Input['DataSetFiltersOperationArgs']]:
+        return pulumi.get(self, "filters_step")
+
+    @filters_step.setter
+    def filters_step(self, value: Optional[pulumi.Input['DataSetFiltersOperationArgs']]):
+        pulumi.set(self, "filters_step", value)
+
+    @_builtins.property
+    @pulumi.getter(name="importTableStep")
+    def import_table_step(self) -> Optional[pulumi.Input['DataSetImportTableOperationArgs']]:
+        return pulumi.get(self, "import_table_step")
+
+    @import_table_step.setter
+    def import_table_step(self, value: Optional[pulumi.Input['DataSetImportTableOperationArgs']]):
+        pulumi.set(self, "import_table_step", value)
+
+    @_builtins.property
+    @pulumi.getter(name="joinStep")
+    def join_step(self) -> Optional[pulumi.Input['DataSetJoinOperationArgs']]:
+        return pulumi.get(self, "join_step")
+
+    @join_step.setter
+    def join_step(self, value: Optional[pulumi.Input['DataSetJoinOperationArgs']]):
+        pulumi.set(self, "join_step", value)
+
+    @_builtins.property
+    @pulumi.getter(name="pivotStep")
+    def pivot_step(self) -> Optional[pulumi.Input['DataSetPivotOperationArgs']]:
+        return pulumi.get(self, "pivot_step")
+
+    @pivot_step.setter
+    def pivot_step(self, value: Optional[pulumi.Input['DataSetPivotOperationArgs']]):
+        pulumi.set(self, "pivot_step", value)
+
+    @_builtins.property
+    @pulumi.getter(name="projectStep")
+    def project_step(self) -> Optional[pulumi.Input['DataSetProjectOperationArgs']]:
+        return pulumi.get(self, "project_step")
+
+    @project_step.setter
+    def project_step(self, value: Optional[pulumi.Input['DataSetProjectOperationArgs']]):
+        pulumi.set(self, "project_step", value)
+
+    @_builtins.property
+    @pulumi.getter(name="renameColumnsStep")
+    def rename_columns_step(self) -> Optional[pulumi.Input['DataSetRenameColumnsOperationArgs']]:
+        return pulumi.get(self, "rename_columns_step")
+
+    @rename_columns_step.setter
+    def rename_columns_step(self, value: Optional[pulumi.Input['DataSetRenameColumnsOperationArgs']]):
+        pulumi.set(self, "rename_columns_step", value)
+
+    @_builtins.property
+    @pulumi.getter(name="unpivotStep")
+    def unpivot_step(self) -> Optional[pulumi.Input['DataSetUnpivotOperationArgs']]:
+        return pulumi.get(self, "unpivot_step")
+
+    @unpivot_step.setter
+    def unpivot_step(self, value: Optional[pulumi.Input['DataSetUnpivotOperationArgs']]):
+        pulumi.set(self, "unpivot_step", value)
+
+
 if not MYPY:
     class DataSetUniqueKeyArgsDict(TypedDict):
-        column_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
+        column_names: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
 elif False:
     DataSetUniqueKeyArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class DataSetUniqueKeyArgs:
     def __init__(__self__, *,
-                 column_names: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
-        if column_names is not None:
-            pulumi.set(__self__, "column_names", column_names)
+                 column_names: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
+        pulumi.set(__self__, "column_names", column_names)
 
     @_builtins.property
     @pulumi.getter(name="columnNames")
-    def column_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
+    def column_names(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
         return pulumi.get(self, "column_names")
 
     @column_names.setter
-    def column_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
+    def column_names(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
         pulumi.set(self, "column_names", value)
 
 
+if not MYPY:
+    class DataSetUnpivotOperationArgsDict(TypedDict):
+        alias: pulumi.Input[_builtins.str]
+        columns_to_unpivot: pulumi.Input[Sequence[pulumi.Input['DataSetColumnToUnpivotArgsDict']]]
+        source: pulumi.Input['DataSetTransformOperationSourceArgsDict']
+        unpivoted_label_column_id: pulumi.Input[_builtins.str]
+        unpivoted_label_column_name: pulumi.Input[_builtins.str]
+        unpivoted_value_column_id: pulumi.Input[_builtins.str]
+        unpivoted_value_column_name: pulumi.Input[_builtins.str]
+elif False:
+    DataSetUnpivotOperationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetUnpivotOperationArgs:
+    def __init__(__self__, *,
+                 alias: pulumi.Input[_builtins.str],
+                 columns_to_unpivot: pulumi.Input[Sequence[pulumi.Input['DataSetColumnToUnpivotArgs']]],
+                 source: pulumi.Input['DataSetTransformOperationSourceArgs'],
+                 unpivoted_label_column_id: pulumi.Input[_builtins.str],
+                 unpivoted_label_column_name: pulumi.Input[_builtins.str],
+                 unpivoted_value_column_id: pulumi.Input[_builtins.str],
+                 unpivoted_value_column_name: pulumi.Input[_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) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "alias")
+
+    @alias.setter
+    def alias(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "alias", value)
+
+    @_builtins.property
+    @pulumi.getter(name="columnsToUnpivot")
+    def columns_to_unpivot(self) -> pulumi.Input[Sequence[pulumi.Input['DataSetColumnToUnpivotArgs']]]:
+        return pulumi.get(self, "columns_to_unpivot")
+
+    @columns_to_unpivot.setter
+    def columns_to_unpivot(self, value: pulumi.Input[Sequence[pulumi.Input['DataSetColumnToUnpivotArgs']]]):
+        pulumi.set(self, "columns_to_unpivot", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def source(self) -> pulumi.Input['DataSetTransformOperationSourceArgs']:
+        return pulumi.get(self, "source")
+
+    @source.setter
+    def source(self, value: pulumi.Input['DataSetTransformOperationSourceArgs']):
+        pulumi.set(self, "source", value)
+
+    @_builtins.property
+    @pulumi.getter(name="unpivotedLabelColumnId")
+    def unpivoted_label_column_id(self) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "unpivoted_label_column_id")
+
+    @unpivoted_label_column_id.setter
+    def unpivoted_label_column_id(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "unpivoted_label_column_id", value)
+
+    @_builtins.property
+    @pulumi.getter(name="unpivotedLabelColumnName")
+    def unpivoted_label_column_name(self) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "unpivoted_label_column_name")
+
+    @unpivoted_label_column_name.setter
+    def unpivoted_label_column_name(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "unpivoted_label_column_name", value)
+
+    @_builtins.property
+    @pulumi.getter(name="unpivotedValueColumnId")
+    def unpivoted_value_column_id(self) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "unpivoted_value_column_id")
+
+    @unpivoted_value_column_id.setter
+    def unpivoted_value_column_id(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "unpivoted_value_column_id", value)
+
+    @_builtins.property
+    @pulumi.getter(name="unpivotedValueColumnName")
+    def unpivoted_value_column_name(self) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "unpivoted_value_column_name")
+
+    @unpivoted_value_column_name.setter
+    def unpivoted_value_column_name(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "unpivoted_value_column_name", value)
+
+
 if not MYPY:
     class DataSetUntagColumnOperationArgsDict(TypedDict):
         """
@@ -96179,6 +98467,29 @@ class DataSetUsageConfigurationArgs:
         pulumi.set(self, "disable_use_as_imported_source", value)
 
 
+if not MYPY:
+    class DataSetValueColumnConfigurationArgsDict(TypedDict):
+        aggregation_function: NotRequired[pulumi.Input['DataSetDataPrepAggregationFunctionArgsDict']]
+elif False:
+    DataSetValueColumnConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataSetValueColumnConfigurationArgs:
+    def __init__(__self__, *,
+                 aggregation_function: Optional[pulumi.Input['DataSetDataPrepAggregationFunctionArgs']] = 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[pulumi.Input['DataSetDataPrepAggregationFunctionArgs']]:
+        return pulumi.get(self, "aggregation_function")
+
+    @aggregation_function.setter
+    def aggregation_function(self, value: Optional[pulumi.Input['DataSetDataPrepAggregationFunctionArgs']]):
+        pulumi.set(self, "aggregation_function", value)
+
+
 if not MYPY:
     class DataSourceAmazonElasticsearchParametersArgsDict(TypedDict):
         """