@pulumi/aws-native 1.39.0-alpha.1762494063 → 1.39.0-alpha.1762525151

package/types/output.d.ts

@@ -15580,6 +15580,7 @@ export declare namespace cleanrooms {
     interface ConfiguredTableAthenaTableReference {
         databaseName: string;
         outputLocation?: string;
+        region?: enums.cleanrooms.ConfiguredTableCommercialRegion;
         tableName: string;
         workGroup: string;
     }
@@ -15591,6 +15592,7 @@ export declare namespace cleanrooms {
     }
     interface ConfiguredTableGlueTableReference {
         databaseName: string;
+        region?: enums.cleanrooms.ConfiguredTableCommercialRegion;
         tableName: string;
     }
     interface ConfiguredTableSnowflakeTableReference {
@@ -15817,14 +15819,30 @@ export declare namespace cleanrooms {
      * Specifies the epsilon and noise parameters for the privacy budget template.
      */
     interface ParametersProperties {
+        budgetParameters?: outputs.cleanrooms.PrivacyBudgetTemplateBudgetParameter[];
         /**
          * The epsilon value that you want to use.
          */
-        epsilon: number;
+        epsilon?: number;
+        resourceArn?: string;
         /**
          * Noise added per query is measured in terms of the number of users whose contributions you want to obscure. This value governs the rate at which the privacy budget is depleted.
          */
-        usersNoisePerQuery: number;
+        usersNoisePerQuery?: number;
+    }
+    interface PrivacyBudgetTemplateBudgetParameter {
+        /**
+         * Whether this individual budget parameter automatically refreshes when the budget period resets.
+         */
+        autoRefresh?: enums.cleanrooms.PrivacyBudgetTemplateBudgetParameterAutoRefresh;
+        /**
+         * The budget allocation amount for this specific parameter.
+         */
+        budget: number;
+        /**
+         * The type of budget parameter being configured.
+         */
+        type: enums.cleanrooms.PrivacyBudgetTemplateBudgetParameterType;
     }
 }
 export declare namespace cleanroomsml {
@@ -17464,6 +17482,9 @@ export declare namespace cloudfront {
          *  For more information, see [Response timeout](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/DownloadDistValuesOrigin.html#DownloadDistValuesOriginResponseTimeout) in the *Amazon CloudFront Developer Guide*.
          */
         originReadTimeout?: number;
+        /**
+         * The account ID of the AWS account that owns the VPC origin.
+         */
         ownerAccountId?: string;
         /**
          * The VPC origin ID.
@@ -20755,6 +20776,9 @@ export declare namespace connect {
          */
         automation?: outputs.connect.EvaluationFormTextQuestionAutomation;
     }
+    interface GranularAccessControlConfigurationProperties {
+        dataTableAccessControlConfiguration?: outputs.connect.SecurityProfileDataTableAccessControlConfiguration;
+    }
     /**
      * Contains information about the hours of operation.
      */
@@ -21232,6 +21256,38 @@ export declare namespace connect {
          */
         namespace: string;
     }
+    /**
+     * Defines the access control configuration for data tables.
+     */
+    interface SecurityProfileDataTableAccessControlConfiguration {
+        primaryAttributeAccessControlConfiguration?: outputs.connect.SecurityProfilePrimaryAttributeAccessControlConfigurationItem;
+    }
+    /**
+     * Contains the configuration for record-based access control.
+     */
+    interface SecurityProfilePrimaryAttributeAccessControlConfigurationItem {
+        /**
+         * An array of PrimaryAttributeValue objects.
+         */
+        primaryAttributeValues: outputs.connect.SecurityProfilePrimaryAttributeValue[];
+    }
+    /**
+     * An object defining the access control for a specific attribute and its values.
+     */
+    interface SecurityProfilePrimaryAttributeValue {
+        /**
+         * Specifies the type of access granted. Currently, only "ALLOW" is supported
+         */
+        accessType: enums.connect.SecurityProfilePrimaryAttributeValueAccessType;
+        /**
+         * The name of the primary attribute.
+         */
+        attributeName: string;
+        /**
+         * An array of allowed primary values for the specified primary attribute.
+         */
+        values: string[];
+    }
     /**
      * A key-value pair to associate with a resource.
      */
@@ -24152,6 +24208,20 @@ export declare namespace datasync {
     }
 }
 export declare namespace datazone {
+    /**
+     * Amazon Q properties of the connection.
+     */
+    interface ConnectionAmazonQPropertiesInput {
+        /**
+         * The authentication mode of the connection's AmazonQ properties
+         */
+        authMode?: string;
+        /**
+         * Specifies whether Amazon Q is enabled for the connection
+         */
+        isEnabled?: boolean;
+        profileArn?: string;
+    }
     /**
      * Athena Properties Input
      */
@@ -24312,9 +24382,12 @@ export declare namespace datazone {
         sparkEmrProperties: outputs.datazone.ConnectionSparkEmrPropertiesInput;
     }
     interface ConnectionPropertiesInput6Properties {
-        sparkGlueProperties: outputs.datazone.ConnectionSparkGluePropertiesInput;
+        amazonQProperties: outputs.datazone.ConnectionAmazonQPropertiesInput;
     }
     interface ConnectionPropertiesInput7Properties {
+        sparkGlueProperties: outputs.datazone.ConnectionSparkGluePropertiesInput;
+    }
+    interface ConnectionPropertiesInput8Properties {
         s3Properties: outputs.datazone.ConnectionS3PropertiesInput;
     }
     interface ConnectionRedshiftCredentials0Properties {
@@ -25820,7 +25893,7 @@ export declare namespace dynamodb {
          *
          * You can update the `ResourcePolicy` property if you've specified more than one table using the [AWS ::DynamoDB::GlobalTable](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-dynamodb-globaltable.html) resource.
          */
-        resourcePolicy: outputs.dynamodb.GlobalTableResourcePolicy;
+        resourcePolicy?: outputs.dynamodb.GlobalTableResourcePolicy;
     }
     interface GlobalTableResourcePolicy {
         /**
@@ -31089,7 +31162,7 @@ export declare namespace ecr {
         kmsKey?: string;
     }
     /**
-     * Overrides the default image tag mutability setting of the repository for image tags that match the specified filters.
+     * A filter that specifies which image tags should be excluded from the repository's image tag mutability setting.
      */
     interface RepositoryCreationTemplateImageTagMutabilityExclusionFilter {
         imageTagMutabilityExclusionFilterType: enums.ecr.RepositoryCreationTemplateImageTagMutabilityExclusionFilterImageTagMutabilityExclusionFilterType;
@@ -32420,7 +32493,7 @@ export declare namespace ecs {
          */
         command?: string[];
         /**
-         * The number of ``cpu`` units reserved for the container. This parameter maps to ``CpuShares`` in the docker container create commandand the ``--cpu-shares`` option to docker run.
+         * The number of ``cpu`` units reserved for the container. This parameter maps to ``CpuShares`` in the docker container create command and the ``--cpu-shares`` option to docker run.
          *  This field is optional for tasks using the Fargate launch type, and the only requirement is that the total amount of CPU reserved for all containers within a task be lower than the task-level ``cpu`` value.
          *   You can determine the number of CPU units that are available per EC2 instance type by multiplying the vCPUs listed for that instance type on the [Amazon EC2 Instances](https://docs.aws.amazon.com/ec2/instance-types/) detail page by 1,024.
          *   Linux containers share unallocated CPU units with other containers on the container instance with the same ratio as their allocated amount. For example, if you run a single-container task on a single-core instance type with 512 CPU units specified for that container, and that's the only task running on the container instance, that container could use the full 1,024 CPU unit share at any given time. However, if you launched another copy of the same task on that container instance, each task is guaranteed a minimum of 512 CPU units when needed. Moreover, each container could float to higher CPU usage if the other container was not using it. If both tasks were 100% active all of the time, they would be limited to 512 CPU units.
@@ -33195,7 +33268,7 @@ export declare namespace ecs {
     interface TaskDefinitionRuntimePlatform {
         /**
          * The CPU architecture.
-         *  You can run your Linux tasks on an ARM-based platform by setting the value to ``ARM64``. This option is available for tasks that run on Linux Amazon EC2 instance or Linux containers on Fargate.
+         *  You can run your Linux tasks on an ARM-based platform by setting the value to ``ARM64``. This option is available for tasks that run on Linux Amazon EC2 instance, Amazon ECS Managed Instances, or Linux containers on Fargate.
          */
         cpuArchitecture?: string;
         /**
@@ -34872,8 +34945,17 @@ export declare namespace elasticloadbalancingv2 {
          */
         statusCode: string;
     }
+    /**
+     * Information about a rewrite transform. This transform matches a pattern and replaces it with the specified string.
+     */
     interface ListenerRuleRewriteConfig {
+        /**
+         * The regular expression to match in the input string. The maximum length of the string is 1,024 characters.
+         */
         regex: string;
+        /**
+         * The replacement string to use when rewriting the matched input. The maximum length of the string is 1,024 characters. You can specify capture groups in the regular expression (for example, $1 and $2).
+         */
         replace: string;
     }
     interface ListenerRuleRewriteConfigObject {
@@ -34914,7 +34996,7 @@ export declare namespace elasticloadbalancingv2 {
          */
         queryStringConfig?: outputs.elasticloadbalancingv2.ListenerRuleQueryStringConfig;
         /**
-         * The regular expressions to match against the condition field. The maximum length of each string is 128 characters. Specify only when `Field` is `http-header` , `host-header` , or `path-pattern` .
+         * The regular expressions to match against the condition field. The maximum length of each string is 128 characters. Specify only when ``Field`` is ``http-header``, ``host-header``, or ``path-pattern``.
          */
         regexValues?: string[];
         /**
@@ -52085,6 +52167,13 @@ export declare namespace lightsail {
     }
 }
 export declare namespace location {
+    interface ApiKeyAndroidApp {
+        certificateFingerprint: string;
+        package: string;
+    }
+    interface ApiKeyAppleApp {
+        bundleId: string;
+    }
     interface ApiKeyRestrictions {
         /**
          * A list of allowed actions that an API key resource grants permissions to perform. You must have at least one action for each type of resource. For example, if you have a place resource, you must include at least one place action.
@@ -52128,6 +52217,8 @@ export declare namespace location {
          * > You must use these strings exactly. For example, to provide access to map rendering, the only valid action is `geo:GetMap*` as an input to the list. `["geo:GetMap*"]` is valid but `["geo:GetTile"]` is not. Similarly, you cannot use `["geo:SearchPlaceIndexFor*"]` - you must list each of the Place actions separately.
          */
         allowActions: string[];
+        allowAndroidApps?: outputs.location.ApiKeyAndroidApp[];
+        allowAppleApps?: outputs.location.ApiKeyAppleApp[];
         /**
          * An optional list of allowed HTTP referers for which requests must originate from. Requests using this API key from other domains will not be allowed.
          *
@@ -79157,6 +79248,27 @@ export declare namespace quicksight {
          */
         yAxis: enums.quicksight.DashboardSingleYAxisOption;
     }
+    interface DataSetAggregateOperation {
+        aggregations: outputs.quicksight.DataSetAggregation[];
+        alias: string;
+        groupByColumnNames?: string[];
+        source: outputs.quicksight.DataSetTransformOperationSource;
+    }
+    interface DataSetAggregation {
+        aggregationFunction: outputs.quicksight.DataSetDataPrepAggregationFunction;
+        newColumnId: string;
+        newColumnName: string;
+    }
+    interface DataSetAppendOperation {
+        alias: string;
+        appendedColumns: outputs.quicksight.DataSetAppendedColumn[];
+        firstSource?: outputs.quicksight.DataSetTransformOperationSource;
+        secondSource?: outputs.quicksight.DataSetTransformOperationSource;
+    }
+    interface DataSetAppendedColumn {
+        columnName: string;
+        newColumnId: string;
+    }
     /**
      * <p>A calculated column for a dataset.</p>
      */
@@ -79183,7 +79295,7 @@ export declare namespace quicksight {
         /**
          * <p>Column name.</p>
          */
-        columnName?: string;
+        columnName: string;
         /**
          * <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>
@@ -79198,6 +79310,11 @@ export declare namespace quicksight {
          */
         subType?: enums.quicksight.DataSetColumnDataSubType;
     }
+    interface DataSetCastColumnTypesOperation {
+        alias: string;
+        castColumnTypeOperations: outputs.quicksight.DataSetCastColumnTypeOperation[];
+        source: outputs.quicksight.DataSetTransformOperationSource;
+    }
     /**
      * <p>Metadata that contains a description for a column.</p>
      */
@@ -79218,6 +79335,10 @@ export declare namespace quicksight {
          */
         geoSpatialColumnGroup?: outputs.quicksight.DataSetGeoSpatialColumnGroup;
     }
+    interface DataSetColumnIdMapping {
+        sourceColumnId: string;
+        targetColumnId: string;
+    }
     /**
      * <p>A rule defined to grant access on one or more restricted columns.
      *             Each dataset can have multiple rules.
@@ -79255,15 +79376,21 @@ export declare namespace quicksight {
          */
         columnGeographicRole?: enums.quicksight.DataSetGeoSpatialDataRole;
     }
+    interface DataSetColumnToUnpivot {
+        columnName?: string;
+        newValue?: string;
+    }
     /**
      * <p>A transform operation that creates calculated columns. Columns created in one such
      *             operation form a lexical closure.</p>
      */
     interface DataSetCreateColumnsOperation {
+        alias?: string;
         /**
          * <p>Calculated columns to create.</p>
          */
-        columns?: outputs.quicksight.DataSetCalculatedColumn[];
+        columns: outputs.quicksight.DataSetCalculatedColumn[];
+        source?: outputs.quicksight.DataSetTransformOperationSource;
     }
     /**
      * <p>A physical table type built from the results of the custom SQL query.</p>
@@ -79272,7 +79399,7 @@ export declare namespace quicksight {
         /**
          * <p>The column schema from the SQL query result set.</p>
          */
-        columns?: outputs.quicksight.DataSetInputColumn[];
+        columns: outputs.quicksight.DataSetInputColumn[];
         /**
          * <p>The Amazon Resource Name (ARN) of the data source.</p>
          */
@@ -79286,6 +79413,35 @@ export declare namespace quicksight {
          */
         sqlQuery: string;
     }
+    interface DataSetDataPrepAggregationFunction {
+        listAggregation?: outputs.quicksight.DataSetDataPrepListAggregationFunction;
+        percentileAggregation?: outputs.quicksight.DataSetDataPrepPercentileAggregationFunction;
+        simpleAggregation?: outputs.quicksight.DataSetDataPrepSimpleAggregationFunction;
+    }
+    interface DataSetDataPrepConfiguration {
+        destinationTableMap: {
+            [key: string]: outputs.quicksight.DataSetDestinationTable;
+        };
+        sourceTableMap: {
+            [key: string]: outputs.quicksight.DataSetSourceTable;
+        };
+        transformStepMap: {
+            [key: string]: outputs.quicksight.DataSetTransformStep;
+        };
+    }
+    interface DataSetDataPrepListAggregationFunction {
+        distinct: boolean;
+        inputColumnName?: string;
+        separator: string;
+    }
+    interface DataSetDataPrepPercentileAggregationFunction {
+        inputColumnName?: string;
+        percentileValue: number;
+    }
+    interface DataSetDataPrepSimpleAggregationFunction {
+        functionType: enums.quicksight.DataSetDataPrepSimpleAggregationFunctionType;
+        inputColumnName?: string;
+    }
     /**
      * <p>A dataset parameter.</p>
      */
@@ -79307,6 +79463,24 @@ export declare namespace quicksight {
          */
         stringDatasetParameter?: outputs.quicksight.DataSetStringDatasetParameter;
     }
+    interface DataSetDateComparisonFilterCondition {
+        operator: enums.quicksight.DataSetDateComparisonFilterOperator;
+        value?: outputs.quicksight.DataSetDateFilterValue;
+    }
+    interface DataSetDateFilterCondition {
+        columnName?: string;
+        comparisonFilterCondition?: outputs.quicksight.DataSetDateComparisonFilterCondition;
+        rangeFilterCondition?: outputs.quicksight.DataSetDateRangeFilterCondition;
+    }
+    interface DataSetDateFilterValue {
+        staticValue?: string;
+    }
+    interface DataSetDateRangeFilterCondition {
+        includeMaximum?: boolean;
+        includeMinimum?: boolean;
+        rangeMaximum?: outputs.quicksight.DataSetDateFilterValue;
+        rangeMinimum?: outputs.quicksight.DataSetDateFilterValue;
+    }
     /**
      * <p>A date time parameter for a dataset.</p>
      */
@@ -79371,6 +79545,13 @@ export declare namespace quicksight {
          */
         staticValues?: number[];
     }
+    interface DataSetDestinationTable {
+        alias: string;
+        source: outputs.quicksight.DataSetDestinationTableSource;
+    }
+    interface DataSetDestinationTableSource {
+        transformOperationId: string;
+    }
     /**
      * <p>A FieldFolder element is a folder that contains fields and nested subfolders.</p>
      */
@@ -79393,6 +79574,14 @@ export declare namespace quicksight {
          *             evaluates to true are kept in the dataset.</p>
          */
         conditionExpression?: string;
+        dateFilterCondition?: outputs.quicksight.DataSetDateFilterCondition;
+        numericFilterCondition?: outputs.quicksight.DataSetNumericFilterCondition;
+        stringFilterCondition?: outputs.quicksight.DataSetStringFilterCondition;
+    }
+    interface DataSetFiltersOperation {
+        alias: string;
+        filterOperations: outputs.quicksight.DataSetFilterOperation[];
+        source: outputs.quicksight.DataSetTransformOperationSource;
     }
     /**
      * <p>Geospatial column group that denotes a hierarchy.</p>
@@ -79411,6 +79600,14 @@ export declare namespace quicksight {
          */
         name: string;
     }
+    interface DataSetImportTableOperation {
+        alias: string;
+        source: outputs.quicksight.DataSetImportTableOperationSource;
+    }
+    interface DataSetImportTableOperationSource {
+        columnIdMappings?: outputs.quicksight.DataSetColumnIdMapping[];
+        sourceTableId: string;
+    }
     /**
      * <p>The incremental refresh configuration for a dataset.</p>
      */
@@ -79439,6 +79636,7 @@ export declare namespace quicksight {
      * <p>Metadata for a column that is used as the input of a transform operation.</p>
      */
     interface DataSetInputColumn {
+        id?: string;
         /**
          * <p>The name of this column in the underlying data source.</p>
          */
@@ -79521,6 +79719,18 @@ export declare namespace quicksight {
          */
         uniqueKey?: boolean;
     }
+    interface DataSetJoinOperandProperties {
+        outputColumnNameOverrides: outputs.quicksight.DataSetOutputColumnNameOverride[];
+    }
+    interface DataSetJoinOperation {
+        alias: string;
+        leftOperand: outputs.quicksight.DataSetTransformOperationSource;
+        leftOperandProperties?: outputs.quicksight.DataSetJoinOperandProperties;
+        onClause: string;
+        rightOperand: outputs.quicksight.DataSetTransformOperationSource;
+        rightOperandProperties?: outputs.quicksight.DataSetJoinOperandProperties;
+        type: enums.quicksight.DataSetJoinOperationType;
+    }
     /**
      * <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
@@ -79536,10 +79746,7 @@ export declare namespace quicksight {
          * <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>
          */
         dataTransforms?: outputs.quicksight.DataSetTransformOperation[];
-        /**
-         * Source of this logical table.
-         */
-        source?: outputs.quicksight.DataSetLogicalTableSource;
+        source: outputs.quicksight.DataSetLogicalTableSource;
     }
     /**
      * <p>Information about the source of a logical table. This is a variant type structure. For
@@ -79597,6 +79804,24 @@ export declare namespace quicksight {
          */
         stringStaticValues?: string[];
     }
+    interface DataSetNumericComparisonFilterCondition {
+        operator: enums.quicksight.DataSetNumericComparisonFilterOperator;
+        value?: outputs.quicksight.DataSetNumericFilterValue;
+    }
+    interface DataSetNumericFilterCondition {
+        columnName?: string;
+        comparisonFilterCondition?: outputs.quicksight.DataSetNumericComparisonFilterCondition;
+        rangeFilterCondition?: outputs.quicksight.DataSetNumericRangeFilterCondition;
+    }
+    interface DataSetNumericFilterValue {
+        staticValue?: number;
+    }
+    interface DataSetNumericRangeFilterCondition {
+        includeMaximum?: boolean;
+        includeMinimum?: boolean;
+        rangeMaximum?: outputs.quicksight.DataSetNumericFilterValue;
+        rangeMinimum?: outputs.quicksight.DataSetNumericFilterValue;
+    }
     /**
      * <p>Output column.</p>
      */
@@ -79605,6 +79830,7 @@ export declare namespace quicksight {
          * <p>A description for a column.</p>
          */
         description?: string;
+        id?: string;
         /**
          * <p>The display name of the column..</p>
          */
@@ -79618,6 +79844,10 @@ export declare namespace quicksight {
          */
         type?: enums.quicksight.DataSetColumnDataType;
     }
+    interface DataSetOutputColumnNameOverride {
+        outputColumnName: string;
+        sourceColumnName?: string;
+    }
     /**
      * <p>A transform operation that overrides the dataset parameter values that are defined in another dataset.</p>
      */
@@ -79635,6 +79865,10 @@ export declare namespace quicksight {
          */
         parameterName: string;
     }
+    interface DataSetParentDataSet {
+        dataSetArn: string;
+        inputColumns: outputs.quicksight.DataSetInputColumn[];
+    }
     interface DataSetPerformanceConfiguration {
         uniqueKeys?: outputs.quicksight.DataSetUniqueKey[];
     }
@@ -79656,16 +79890,35 @@ export declare namespace quicksight {
          * A physical table type for as S3 data source.
          */
         s3Source?: outputs.quicksight.DataSetS3Source;
+        saaSTable?: outputs.quicksight.DataSetSaaSTable;
+    }
+    interface DataSetPivotConfiguration {
+        labelColumnName?: string;
+        pivotedLabels: outputs.quicksight.DataSetPivotedLabel[];
+    }
+    interface DataSetPivotOperation {
+        alias: string;
+        groupByColumnNames?: string[];
+        pivotConfiguration: outputs.quicksight.DataSetPivotConfiguration;
+        source: outputs.quicksight.DataSetTransformOperationSource;
+        valueColumnConfiguration: outputs.quicksight.DataSetValueColumnConfiguration;
+    }
+    interface DataSetPivotedLabel {
+        labelName: string;
+        newColumnId: string;
+        newColumnName: string;
     }
     /**
      * <p>A transform operation that projects columns. Operations that come after a projection
      *             can only refer to projected columns.</p>
      */
     interface DataSetProjectOperation {
+        alias?: string;
         /**
          * <p>Projected columns.</p>
          */
         projectedColumns?: string[];
+        source?: outputs.quicksight.DataSetTransformOperationSource;
     }
     /**
      * <p>The refresh configuration of a dataset.</p>
@@ -79716,7 +79969,7 @@ export declare namespace quicksight {
         /**
          * <p>The column schema of the table.</p>
          */
-        inputColumns?: outputs.quicksight.DataSetInputColumn[];
+        inputColumns: outputs.quicksight.DataSetInputColumn[];
         /**
          * <p>The name of the relational table.</p>
          */
@@ -79733,11 +79986,16 @@ export declare namespace quicksight {
         /**
          * <p>The name of the column to be renamed.</p>
          */
-        columnName?: string;
+        columnName: string;
         /**
          * <p>The new name for the column.</p>
          */
-        newColumnName?: string;
+        newColumnName: string;
+    }
+    interface DataSetRenameColumnsOperation {
+        alias: string;
+        renameColumnOperations: outputs.quicksight.DataSetRenameColumnOperation[];
+        source: outputs.quicksight.DataSetTransformOperationSource;
     }
     /**
      * <p>Permission for the resource.</p>
@@ -79766,6 +80024,10 @@ export declare namespace quicksight {
          */
         principal: string;
     }
+    interface DataSetRowLevelPermissionConfiguration {
+        rowLevelPermissionDataSet?: outputs.quicksight.DataSetRowLevelPermissionDataSet;
+        tagConfiguration?: outputs.quicksight.DataSetRowLevelPermissionTagConfiguration;
+    }
     /**
      * <p>Information about a dataset that contains permissions for row-level security (RLS).
      *             The permissions dataset maps fields to users or groups. For more information, see
@@ -79822,7 +80084,7 @@ export declare namespace quicksight {
         /**
          * <p>The column name that a tag key is assigned to.</p>
          */
-        columnName?: string;
+        columnName: string;
         /**
          * <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>
          */
@@ -79850,12 +80112,35 @@ export declare namespace quicksight {
          *             <p>For files that aren't JSON, only <code>STRING</code> data types are supported in input columns.</p>
          *          </note>
          */
-        inputColumns?: outputs.quicksight.DataSetInputColumn[];
+        inputColumns: outputs.quicksight.DataSetInputColumn[];
         /**
          * Information about the format for the S3 source file or files.
          */
         uploadSettings?: outputs.quicksight.DataSetUploadSettings;
     }
+    interface DataSetSaaSTable {
+        dataSourceArn: string;
+        inputColumns: outputs.quicksight.DataSetInputColumn[];
+        tablePath: outputs.quicksight.DataSetTablePathElement[];
+    }
+    interface DataSetSemanticModelConfiguration {
+        tableMap?: {
+            [key: string]: outputs.quicksight.DataSetSemanticTable;
+        };
+    }
+    interface DataSetSemanticTable {
+        alias: string;
+        destinationTableId: string;
+        rowLevelPermissionConfiguration?: outputs.quicksight.DataSetRowLevelPermissionConfiguration;
+    }
+    interface DataSetSourceTable {
+        dataSet?: outputs.quicksight.DataSetParentDataSet;
+        physicalTableId?: string;
+    }
+    interface DataSetStringComparisonFilterCondition {
+        operator: enums.quicksight.DataSetStringComparisonFilterOperator;
+        value?: outputs.quicksight.DataSetStringFilterValue;
+    }
     /**
      * <p>A string parameter for a dataset.</p>
      */
@@ -79886,6 +80171,25 @@ export declare namespace quicksight {
          */
         staticValues?: string[];
     }
+    interface DataSetStringFilterCondition {
+        columnName?: string;
+        comparisonFilterCondition?: outputs.quicksight.DataSetStringComparisonFilterCondition;
+        listFilterCondition?: outputs.quicksight.DataSetStringListFilterCondition;
+    }
+    interface DataSetStringFilterValue {
+        staticValue?: string;
+    }
+    interface DataSetStringListFilterCondition {
+        operator: enums.quicksight.DataSetStringListFilterOperator;
+        values?: outputs.quicksight.DataSetStringListFilterValue;
+    }
+    interface DataSetStringListFilterValue {
+        staticValues?: string[];
+    }
+    interface DataSetTablePathElement {
+        id?: string;
+        name?: string;
+    }
     /**
      * <p>A transform operation that tags a column with additional information.</p>
      */
@@ -79937,8 +80241,34 @@ export declare namespace quicksight {
         tagColumnOperation?: outputs.quicksight.DataSetTagColumnOperation;
         untagColumnOperation?: outputs.quicksight.DataSetUntagColumnOperation;
     }
+    interface DataSetTransformOperationSource {
+        columnIdMappings?: outputs.quicksight.DataSetColumnIdMapping[];
+        transformOperationId: string;
+    }
+    interface DataSetTransformStep {
+        aggregateStep?: outputs.quicksight.DataSetAggregateOperation;
+        appendStep?: outputs.quicksight.DataSetAppendOperation;
+        castColumnTypesStep?: outputs.quicksight.DataSetCastColumnTypesOperation;
+        createColumnsStep?: outputs.quicksight.DataSetCreateColumnsOperation;
+        filtersStep?: outputs.quicksight.DataSetFiltersOperation;
+        importTableStep?: outputs.quicksight.DataSetImportTableOperation;
+        joinStep?: outputs.quicksight.DataSetJoinOperation;
+        pivotStep?: outputs.quicksight.DataSetPivotOperation;
+        projectStep?: outputs.quicksight.DataSetProjectOperation;
+        renameColumnsStep?: outputs.quicksight.DataSetRenameColumnsOperation;
+        unpivotStep?: outputs.quicksight.DataSetUnpivotOperation;
+    }
     interface DataSetUniqueKey {
-        columnNames?: string[];
+        columnNames: string[];
+    }
+    interface DataSetUnpivotOperation {
+        alias: string;
+        columnsToUnpivot: outputs.quicksight.DataSetColumnToUnpivot[];
+        source: outputs.quicksight.DataSetTransformOperationSource;
+        unpivotedLabelColumnId: string;
+        unpivotedLabelColumnName: string;
+        unpivotedValueColumnId: string;
+        unpivotedValueColumnName: string;
     }
     /**
      * <p>A transform operation that removes tags associated with a column.</p>
@@ -79991,6 +80321,9 @@ export declare namespace quicksight {
          */
         disableUseAsImportedSource?: boolean;
     }
+    interface DataSetValueColumnConfiguration {
+        aggregationFunction?: outputs.quicksight.DataSetDataPrepAggregationFunction;
+    }
     /**
      * <p>The parameters for OpenSearch.</p>
      */
@@ -100729,6 +101062,83 @@ export declare namespace securitylake {
     }
 }
 export declare namespace servicecatalog {
+    interface CloudFormationProductCodeStarParameters {
+        /**
+         * The absolute path where the artifact resides within the repo and branch, formatted as "folder/file.json".
+         */
+        artifactPath: string;
+        /**
+         * The specific branch where the artifact resides.
+         */
+        branch: string;
+        /**
+         * The CodeStar ARN, which is the connection between AWS Service Catalog and the external repository.
+         */
+        connectionArn: string;
+        /**
+         * The specific repository where the product's artifact-to-be-synced resides, formatted as "Account/Repo."
+         */
+        repository: string;
+    }
+    interface CloudFormationProductProvisioningArtifactProperties {
+        /**
+         * The description of the provisioning artifact, including how it differs from the previous provisioning artifact.
+         */
+        description?: string;
+        /**
+         * If set to true, AWS Service Catalog stops validating the specified provisioning artifact even if it is invalid.
+         */
+        disableTemplateValidation?: boolean;
+        /**
+         * Specify the template source with one of the following options, but not both. Keys accepted: [ LoadTemplateFromURL, ImportFromPhysicalId ] The URL of the AWS CloudFormation template in Amazon S3 in JSON format. Specify the URL in JSON format as follows:
+         *
+         * "LoadTemplateFromURL": "https://s3.amazonaws.com/cf-templates-ozkq9d3hgiq2-us-east-1/..."
+         *
+         * ImportFromPhysicalId: The physical id of the resource that contains the template. Currently only supports AWS CloudFormation stack arn. Specify the physical id in JSON format as follows: ImportFromPhysicalId: "arn:aws:cloudformation:[us-east-1]:[accountId]:stack/[StackName]/[resourceId]
+         */
+        info: outputs.servicecatalog.CloudFormationProductProvisioningArtifactPropertiesInfoProperties;
+        /**
+         * The name of the provisioning artifact (for example, v1 v2beta). No spaces are allowed.
+         */
+        name?: string;
+        /**
+         * The type of provisioning artifact. Valid values are CLOUD_FORMATION_TEMPLATE, TERRAFORM_OPEN_SOURCE, TERRAFORM_CLOUD, EXTERNAL
+         */
+        type?: enums.servicecatalog.CloudFormationProductProvisioningArtifactPropertiesType;
+    }
+    /**
+     * Specify the template source with one of the following options, but not both. Keys accepted: [ LoadTemplateFromURL, ImportFromPhysicalId ] The URL of the AWS CloudFormation template in Amazon S3 in JSON format. Specify the URL in JSON format as follows:
+     *
+     * "LoadTemplateFromURL": "https://s3.amazonaws.com/cf-templates-ozkq9d3hgiq2-us-east-1/..."
+     *
+     * ImportFromPhysicalId: The physical id of the resource that contains the template. Currently only supports AWS CloudFormation stack arn. Specify the physical id in JSON format as follows: ImportFromPhysicalId: "arn:aws:cloudformation:[us-east-1]:[accountId]:stack/[StackName]/[resourceId]
+     */
+    interface CloudFormationProductProvisioningArtifactPropertiesInfoProperties {
+        /**
+         * The physical id of the resource that contains the template. Currently only supports AWS CloudFormation stack arn
+         */
+        importFromPhysicalId?: string;
+        /**
+         * The URL of the AWS CloudFormation template in Amazon S3 in JSON format.
+         */
+        loadTemplateFromUrl?: string;
+    }
+    interface CloudFormationProductSourceConnection {
+        /**
+         * The connection details based on the connection Type.
+         */
+        connectionParameters: outputs.servicecatalog.CloudFormationProductSourceConnectionConnectionParametersProperties;
+        /**
+         * The only supported SourceConnection type is Codestar.
+         */
+        type: string;
+    }
+    /**
+     * The connection details based on the connection Type.
+     */
+    interface CloudFormationProductSourceConnectionConnectionParametersProperties {
+        codeStar?: outputs.servicecatalog.CloudFormationProductCodeStarParameters;
+    }
     interface CloudFormationProvisionedProductProvisioningParameter {
         /**
          * The parameter key.
@@ -101363,6 +101773,15 @@ export declare namespace ses {
          */
         conditions: (outputs.ses.MailManagerTrafficPolicyPolicyCondition0Properties | outputs.ses.MailManagerTrafficPolicyPolicyCondition1Properties | outputs.ses.MailManagerTrafficPolicyPolicyCondition2Properties | outputs.ses.MailManagerTrafficPolicyPolicyCondition3Properties | outputs.ses.MailManagerTrafficPolicyPolicyCondition4Properties)[];
     }
+    /**
+     * Contains details of a multi-region endpoint (global-endpoint) being created.
+     */
+    interface MultiRegionEndpointDetails {
+        routeDetails: outputs.ses.MultiRegionEndpointRouteDetailsItemProperties[];
+    }
+    interface MultiRegionEndpointRouteDetailsItemProperties {
+        region: string;
+    }
     /**
      * The content of the email, composed of a subject line, an HTML part, and a text-only part
      */
@@ -105493,6 +105912,9 @@ export declare namespace wafv2 {
      * Configures the ability for the WAF; console to store and retrieve application attributes during the webacl; creation process. Application attributes help WAF; give recommendations for protection packs.
      */
     interface WebAclApplicationConfig {
+        /**
+         * Contains the attribute name and a list of values for that attribute.
+         */
         attributes: outputs.wafv2.WebAclApplicationAttribute[];
     }
     interface WebAclAsnMatchStatement {