@pulumi/aws-native 1.77.0 → 1.78.0

package/types/input.d.ts

@@ -934,6 +934,12 @@ export declare namespace agentregistry {
         dataSchemaVersion?: pulumi.Input<string | undefined>;
         source?: pulumi.Input<inputs.agentregistry.RegistryRecordDescriptorSourceArgs | undefined>;
     }
+    /**
+     * The AG-UI (Agent-User Interaction) descriptor, populated for records detected from an AG-UI protocol source. This descriptor is source-only: its content is synchronized from the configured source URL rather than supplied inline.
+     */
+    interface RegistryRecordAgUiDescriptorArgs {
+        source?: pulumi.Input<inputs.agentregistry.RegistryRecordSourceOnlyDescriptorSourceArgs | undefined>;
+    }
     /**
      * Additional data associated with an agent skills definition descriptor.
      */
@@ -1007,9 +1013,17 @@ export declare namespace agentregistry {
     interface RegistryRecordDescriptorsArgs {
         a2aAgentCard?: pulumi.Input<inputs.agentregistry.RegistryRecordA2aAgentCardDescriptorArgs | undefined>;
         agentSkillsDefinition?: pulumi.Input<inputs.agentregistry.RegistryRecordAgentSkillsDefinitionDescriptorArgs | undefined>;
+        agui?: pulumi.Input<inputs.agentregistry.RegistryRecordAgUiDescriptorArgs | undefined>;
         custom?: pulumi.Input<inputs.agentregistry.RegistryRecordCustomDescriptorArgs | undefined>;
+        http?: pulumi.Input<inputs.agentregistry.RegistryRecordHttpDescriptorArgs | undefined>;
         mcpServer?: pulumi.Input<inputs.agentregistry.RegistryRecordMcpServerDescriptorArgs | undefined>;
     }
+    /**
+     * The HTTP descriptor, populated for records detected from an HTTP protocol source. This descriptor is source-only: its content is synchronized from the configured source URL rather than supplied inline.
+     */
+    interface RegistryRecordHttpDescriptorArgs {
+        source?: pulumi.Input<inputs.agentregistry.RegistryRecordSourceOnlyDescriptorSourceArgs | undefined>;
+    }
     /**
      * IAM credential provider configuration.
      */
@@ -1090,6 +1104,21 @@ export declare namespace agentregistry {
          */
         url: pulumi.Input<string>;
     }
+    /**
+     * Source configuration for a source-only descriptor. Unlike mcpServer/a2aAgentCard sources, source-only descriptors do not support credential providers.
+     */
+    interface RegistryRecordSourceOnlyDescriptorSourceArgs {
+        fromUrl?: pulumi.Input<inputs.agentregistry.RegistryRecordSourceOnlyDescriptorSourceFromUrlArgs | undefined>;
+    }
+    /**
+     * URL-based source configuration for a source-only descriptor.
+     */
+    interface RegistryRecordSourceOnlyDescriptorSourceFromUrlArgs {
+        /**
+         * URL source for descriptor content.
+         */
+        url: pulumi.Input<string>;
+    }
 }
 export declare namespace aiops {
     interface InvestigationGroupChatbotNotificationChannelArgs {
@@ -3036,6 +3065,17 @@ export declare namespace appconfig {
          */
         weight: pulumi.Input<number>;
     }
+    /**
+     * Treatment overrides for specific entities.
+     */
+    interface ExperimentRunTreatmentOverridesArgs {
+        /**
+         * Map of entity ID to treatment key (t1, t2, ..., or c for control).
+         */
+        inline?: pulumi.Input<{
+            [key: string]: pulumi.Input<string>;
+        } | undefined>;
+    }
     /**
      * An action for an extension to take at a specific action point.
      */
@@ -18446,6 +18486,21 @@ export declare namespace chatbot {
         commandText: pulumi.Input<string>;
     }
 }
+export declare namespace chime {
+    /**
+     * The configuration settings for the Kinesis video stream.
+     */
+    interface StreamConfigurationPropertiesArgs {
+        /**
+         * The amount of time that data is retained, in hours.
+         */
+        dataRetentionInHours?: pulumi.Input<number | undefined>;
+        /**
+         * The AWS Region of the video stream.
+         */
+        region: pulumi.Input<string>;
+    }
+}
 export declare namespace cleanrooms {
     interface AnalysisTemplateAnalysisParameterArgs {
         /**
@@ -18652,6 +18707,13 @@ export declare namespace cleanrooms {
         minimum: pulumi.Input<number>;
         type: pulumi.Input<enums.cleanrooms.ConfiguredTableAggregationType>;
     }
+    interface ConfiguredTableAggregationThresholdArgs {
+        allowedAggregateExpressionType: pulumi.Input<enums.cleanrooms.ConfiguredTableAllowedAggregateExpressionType>;
+        identityColumns: pulumi.Input<pulumi.Input<string>[]>;
+        minimumIdentityCount: pulumi.Input<number>;
+        outputColumnThresholds?: pulumi.Input<pulumi.Input<inputs.cleanrooms.ConfiguredTableOutputColumnThresholdArgs>[] | undefined>;
+        type: pulumi.Input<enums.cleanrooms.ConfiguredTableAggregationThresholdType>;
+    }
     interface ConfiguredTableAnalysisRuleArgs {
         /**
          * A policy that describes the associated data usage limitations.
@@ -18674,8 +18736,10 @@ export declare namespace cleanrooms {
     }
     interface ConfiguredTableAnalysisRuleCustomArgs {
         additionalAnalyses?: pulumi.Input<enums.cleanrooms.ConfiguredTableAdditionalAnalyses | undefined>;
+        aggregationThresholds?: pulumi.Input<pulumi.Input<inputs.cleanrooms.ConfiguredTableAggregationThresholdArgs>[] | undefined>;
         allowedAnalyses: pulumi.Input<pulumi.Input<string>[]>;
         allowedAnalysisProviders?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+        comparisonControls?: pulumi.Input<inputs.cleanrooms.ConfiguredTableComparisonControlsArgs | undefined>;
         differentialPrivacy?: pulumi.Input<inputs.cleanrooms.ConfiguredTableDifferentialPrivacyArgs | undefined>;
         disallowedOutputColumns?: pulumi.Input<pulumi.Input<string>[] | undefined>;
     }
@@ -18745,6 +18809,10 @@ export declare namespace cleanrooms {
         tableName: pulumi.Input<string>;
         workGroup: pulumi.Input<string>;
     }
+    interface ConfiguredTableComparisonControlsArgs {
+        allowedColumnComparisonColumns: pulumi.Input<pulumi.Input<string>[]>;
+        allowedLiteralComparisonColumns: pulumi.Input<pulumi.Input<string>[]>;
+    }
     interface ConfiguredTableDifferentialPrivacyArgs {
         columns: pulumi.Input<pulumi.Input<inputs.cleanrooms.ConfiguredTableDifferentialPrivacyColumnArgs>[]>;
     }
@@ -18756,6 +18824,10 @@ export declare namespace cleanrooms {
         region?: pulumi.Input<enums.cleanrooms.ConfiguredTableCommercialRegion | undefined>;
         tableName: pulumi.Input<string>;
     }
+    interface ConfiguredTableOutputColumnThresholdArgs {
+        minimumIdentityCount: pulumi.Input<number>;
+        outputColumnName: pulumi.Input<string>;
+    }
     interface ConfiguredTableSnowflakeTableReferenceArgs {
         accountIdentifier: pulumi.Input<string>;
         databaseName: pulumi.Input<string>;
@@ -18812,15 +18884,24 @@ export declare namespace cleanrooms {
          */
         manageResourcePolicies: pulumi.Input<boolean>;
     }
+    interface IntermediateTableAggregationThresholdArgs {
+        allowedAggregateExpressionType: pulumi.Input<enums.cleanrooms.IntermediateTableAllowedAggregateExpressionType>;
+        identityColumns: pulumi.Input<pulumi.Input<string>[]>;
+        minimumIdentityCount: pulumi.Input<number>;
+        outputColumnThresholds?: pulumi.Input<pulumi.Input<inputs.cleanrooms.IntermediateTableOutputColumnThresholdArgs>[] | undefined>;
+        type: pulumi.Input<enums.cleanrooms.IntermediateTableAggregationThresholdType>;
+    }
     interface IntermediateTableAnalysisRuleArgs {
         policy: pulumi.Input<inputs.cleanrooms.IntermediateTableAnalysisRulePolicyArgs>;
         type: pulumi.Input<enums.cleanrooms.IntermediateTableAnalysisRuleType>;
     }
     interface IntermediateTableAnalysisRuleCustomArgs {
         additionalAnalyses?: pulumi.Input<enums.cleanrooms.IntermediateTableAdditionalAnalyses | undefined>;
+        aggregationThresholds?: pulumi.Input<pulumi.Input<inputs.cleanrooms.IntermediateTableAggregationThresholdArgs>[] | undefined>;
         allowedAnalyses: pulumi.Input<pulumi.Input<string>[]>;
         allowedAnalysisProviders?: pulumi.Input<pulumi.Input<string>[] | undefined>;
         allowedResultReceivers?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+        comparisonControls?: pulumi.Input<inputs.cleanrooms.IntermediateTableComparisonControlsArgs | undefined>;
         differentialPrivacy?: pulumi.Input<inputs.cleanrooms.IntermediateTableDifferentialPrivacyArgs | undefined>;
         disallowedOutputColumns?: pulumi.Input<pulumi.Input<string>[] | undefined>;
     }
@@ -18830,12 +18911,20 @@ export declare namespace cleanrooms {
     interface IntermediateTableAnalysisRulePolicyV1PropertiesArgs {
         custom: pulumi.Input<inputs.cleanrooms.IntermediateTableAnalysisRuleCustomArgs>;
     }
+    interface IntermediateTableComparisonControlsArgs {
+        allowedColumnComparisonColumns: pulumi.Input<pulumi.Input<string>[]>;
+        allowedLiteralComparisonColumns: pulumi.Input<pulumi.Input<string>[]>;
+    }
     interface IntermediateTableDifferentialPrivacyArgs {
         columns: pulumi.Input<pulumi.Input<inputs.cleanrooms.IntermediateTableDifferentialPrivacyColumnArgs>[]>;
     }
     interface IntermediateTableDifferentialPrivacyColumnArgs {
         name: pulumi.Input<string>;
     }
+    interface IntermediateTableOutputColumnThresholdArgs {
+        minimumIdentityCount: pulumi.Input<number>;
+        outputColumnName: pulumi.Input<string>;
+    }
     interface IntermediateTablePopulationAnalysisConfigurationArgs {
         sqlParameters?: pulumi.Input<inputs.cleanrooms.IntermediateTablePopulationAnalysisSqlParametersArgs | undefined>;
     }
@@ -31471,6 +31560,518 @@ export declare namespace directoryservice {
         vpcId: pulumi.Input<string>;
     }
 }
+export declare namespace dlm {
+    interface LifecyclePolicyActionArgs {
+        /**
+         * The rule for copying shared snapshots across Regions.
+         */
+        crossRegionCopy: pulumi.Input<pulumi.Input<inputs.dlm.LifecyclePolicyCrossRegionCopyActionArgs>[]>;
+        /**
+         * A descriptive name for the action.
+         */
+        name: pulumi.Input<string>;
+    }
+    /**
+     * Information about the retention period for the snapshot archiving rule.
+     */
+    interface LifecyclePolicyArchiveRetainRuleArgs {
+        /**
+         * Information about retention period in the Amazon EBS Snapshots Archive. For more information, see [Archive Amazon EBS snapshots](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/snapshot-archive.html) .
+         */
+        retentionArchiveTier: pulumi.Input<inputs.dlm.LifecyclePolicyRetentionArchiveTierArgs>;
+    }
+    /**
+     * **[Custom snapshot policies that target volumes only]** The snapshot archiving rule for the schedule. When you specify an archiving rule, snapshots are automatically moved from the standard tier to the archive tier once the schedule's retention threshold is met. Snapshots are then retained in the archive tier for the archive retention period that you specify.
+     */
+    interface LifecyclePolicyArchiveRuleArgs {
+        /**
+         * Information about the retention period for the snapshot archiving rule.
+         */
+        retainRule: pulumi.Input<inputs.dlm.LifecyclePolicyArchiveRetainRuleArgs>;
+    }
+    /**
+     * The creation rule.
+     */
+    interface LifecyclePolicyCreateRuleArgs {
+        /**
+         * The schedule, as a Cron expression. The schedule interval must be between 1 hour and 1 year.
+         */
+        cronExpression?: pulumi.Input<string | undefined>;
+        /**
+         * The interval between snapshots. The supported values are 1, 2, 3, 4, 6, 8, 12, and 24.
+         */
+        interval?: pulumi.Input<number | undefined>;
+        /**
+         * The interval unit.
+         */
+        intervalUnit?: pulumi.Input<string | undefined>;
+        /**
+         * **[Custom snapshot policies only]** Specifies the destination for snapshots created by the policy. The allowed destinations depend on the location of the targeted resources.
+         *
+         * - If the policy targets resources in a Region, then you must create snapshots in the same Region as the source resource.
+         * - If the policy targets resources in a Local Zone, you can create snapshots in the same Local Zone or in its parent Region.
+         * - If the policy targets resources on an Outpost, then you can create snapshots on the same Outpost or in its parent Region.
+         *
+         * Default: `CLOUD`
+         */
+        location?: pulumi.Input<string | undefined>;
+        /**
+         * **[Custom snapshot policies that target instances only]** Specifies pre and/or post scripts for a snapshot lifecycle policy that targets instances. This is useful for creating application-consistent snapshots, or for performing specific administrative tasks before or after Amazon Data Lifecycle Manager initiates snapshot creation.
+         */
+        scripts?: pulumi.Input<pulumi.Input<inputs.dlm.LifecyclePolicyScriptArgs>[] | undefined>;
+        /**
+         * The time, in UTC, to start the operation. The supported format is hh:mm.
+         *
+         * The operation occurs within a one-hour window following the specified time. If you do not specify a time, Amazon Data Lifecycle Manager selects a time within the next 24 hours.
+         */
+        times?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+    }
+    interface LifecyclePolicyCrossRegionCopyActionArgs {
+        /**
+         * The encryption settings for the copied snapshot.
+         */
+        encryptionConfiguration: pulumi.Input<inputs.dlm.LifecyclePolicyEncryptionConfigurationArgs>;
+        /**
+         * Specifies a retention rule for cross-Region snapshot copies created by snapshot or event-based policies, or cross-Region AMI copies created by AMI policies. After the retention period expires, the cross-Region copy is deleted.
+         */
+        retainRule?: pulumi.Input<inputs.dlm.LifecyclePolicyCrossRegionCopyRetainRuleArgs | undefined>;
+        /**
+         * The target Region.
+         */
+        target: pulumi.Input<string>;
+    }
+    /**
+     * **[Custom AMI policies only]** The AMI deprecation rule for cross-Region AMI copies created by the rule.
+     */
+    interface LifecyclePolicyCrossRegionCopyDeprecateRuleArgs {
+        /**
+         * The period after which to deprecate the cross-Region AMI copies. The period must be less than or equal to the cross-Region AMI copy retention period, and it can't be greater than 10 years. This is equivalent to 120 months, 520 weeks, or 3650 days.
+         */
+        interval: pulumi.Input<number>;
+        /**
+         * The unit of time in which to measure the **Interval**. For example, to deprecate a cross-Region AMI copy after 3 months, specify `Interval=3` and `IntervalUnit=MONTHS`.
+         */
+        intervalUnit: pulumi.Input<string>;
+    }
+    /**
+     * The retention rule that indicates how long the cross-Region snapshot or AMI copies are to be retained in the destination Region.
+     */
+    interface LifecyclePolicyCrossRegionCopyRetainRuleArgs {
+        /**
+         * The amount of time to retain a cross-Region snapshot or AMI copy. The maximum is 100 years. This is equivalent to 1200 months, 5200 weeks, or 36500 days.
+         */
+        interval: pulumi.Input<number>;
+        /**
+         * The unit of time for time-based retention. For example, to retain a cross-Region copy for 3 months, specify `Interval=3` and `IntervalUnit=MONTHS`.
+         */
+        intervalUnit: pulumi.Input<string>;
+    }
+    interface LifecyclePolicyCrossRegionCopyRuleArgs {
+        /**
+         * The Amazon Resource Name (ARN) of the AWS KMS key to use for EBS encryption. If this parameter is not specified, the default KMS key for the account is used.
+         */
+        cmkArn?: pulumi.Input<string | undefined>;
+        /**
+         * Indicates whether to copy all user-defined tags from the source snapshot or AMI to the cross-Region copy.
+         */
+        copyTags?: pulumi.Input<boolean | undefined>;
+        /**
+         * *[Custom AMI policies only]* The AMI deprecation rule for cross-Region AMI copies created by the rule.
+         */
+        deprecateRule?: pulumi.Input<inputs.dlm.LifecyclePolicyCrossRegionCopyDeprecateRuleArgs | undefined>;
+        /**
+         * To encrypt a copy of an unencrypted snapshot if encryption by default is not enabled, enable encryption using this parameter. Copies of encrypted snapshots are encrypted, even if this parameter is `false` or if encryption by default is not enabled.
+         */
+        encrypted: pulumi.Input<boolean>;
+        /**
+         * The retention rule that indicates how long the cross-Region snapshot or AMI copies are to be retained in the destination Region.
+         */
+        retainRule?: pulumi.Input<inputs.dlm.LifecyclePolicyCrossRegionCopyRetainRuleArgs | undefined>;
+        /**
+         * **[Custom snapshot policies only]** The target Region or the Amazon Resource Name (ARN) of the target Outpost for the snapshot copies.
+         */
+        target?: pulumi.Input<string | undefined>;
+        /**
+         * **[Custom AMI policies only]** The target Region or the Amazon Resource Name (ARN) of the target Outpost for the AMI copies.
+         */
+        targetRegion?: pulumi.Input<string | undefined>;
+    }
+    interface LifecyclePolicyCrossRegionCopyTargetArgs {
+        /**
+         * The target Region, for example `us-east-1`.
+         */
+        targetRegion?: pulumi.Input<string | undefined>;
+    }
+    /**
+     * **[Custom AMI policies only]** The AMI deprecation rule for the schedule.
+     */
+    interface LifecyclePolicyDeprecateRuleArgs {
+        /**
+         * If the schedule has a count-based retention rule, this parameter specifies the number of oldest AMIs to deprecate. The count must be less than or equal to the schedule's retention count, and it can't be greater than 1000.
+         */
+        count?: pulumi.Input<number | undefined>;
+        /**
+         * If the schedule has an age-based retention rule, this parameter specifies the period after which to deprecate AMIs created by the schedule. The period must be less than or equal to the schedule's retention period, and it can't be greater than 10 years. This is equivalent to 120 months, 520 weeks, or 3650 days.
+         */
+        interval?: pulumi.Input<number | undefined>;
+        /**
+         * The unit of time in which to measure the **Interval**.
+         */
+        intervalUnit?: pulumi.Input<string | undefined>;
+    }
+    /**
+     * The encryption settings for the copied snapshot.
+     */
+    interface LifecyclePolicyEncryptionConfigurationArgs {
+        /**
+         * The Amazon Resource Name (ARN) of the AWS KMS key to use for EBS encryption. If this parameter is not specified, the default KMS key for the account is used.
+         */
+        cmkArn?: pulumi.Input<string | undefined>;
+        /**
+         * To encrypt a copy of an unencrypted snapshot when encryption by default is not enabled, enable encryption using this parameter. Copies of encrypted snapshots are encrypted, even if this parameter is `false` or when encryption by default is not enabled.
+         */
+        encrypted: pulumi.Input<boolean>;
+    }
+    /**
+     * Information about the event.
+     */
+    interface LifecyclePolicyEventParametersArgs {
+        /**
+         * The snapshot description that can trigger the policy. The description pattern is specified using a regular expression. The policy runs only if a snapshot with a description that matches the specified pattern is shared with your account.
+         */
+        descriptionRegex?: pulumi.Input<string | undefined>;
+        /**
+         * The type of event. Currently, only snapshot sharing events are supported.
+         */
+        eventType: pulumi.Input<string>;
+        /**
+         * The IDs of the AWS accounts that can trigger policy by sharing snapshots with your account. The policy only runs if one of the specified AWS accounts shares a snapshot with your account.
+         */
+        snapshotOwner: pulumi.Input<pulumi.Input<string>[]>;
+    }
+    /**
+     * **[Event-based policies only]** The event that activates the event-based policy.
+     */
+    interface LifecyclePolicyEventSourceArgs {
+        /**
+         * Information about the event.
+         */
+        parameters?: pulumi.Input<inputs.dlm.LifecyclePolicyEventParametersArgs | undefined>;
+        /**
+         * The source of the event. Currently only managed Amazon EventBridge events are supported.
+         */
+        type: pulumi.Input<string>;
+    }
+    /**
+     * **[Default policies only]** Specifies exclusion parameters for volumes or instances for which you do not want to create snapshots or AMIs. The policy will not create snapshots or AMIs for target resources that match any of the specified exclusion parameters.
+     */
+    interface LifecyclePolicyExclusionsArgs {
+        /**
+         * **[Default policies for EBS snapshots only]** Indicates whether to exclude volumes that are attached to instances as the boot volume. If you exclude boot volumes, only volumes attached as data (non-boot) volumes will be backed up by the policy. To exclude boot volumes, specify `true`.
+         */
+        excludeBootVolumes?: pulumi.Input<boolean | undefined>;
+        /**
+         * **[Default policies for EBS-backed AMIs only]** Specifies whether to exclude volumes that have specific tags.
+         */
+        excludeTags?: pulumi.Input<pulumi.Input<inputs.dlm.LifecyclePolicyTagArgs>[] | undefined>;
+        /**
+         * *[Default policies for EBS snapshots only]* Specifies the volume types to exclude. Volumes of the specified types will not be targeted by the policy.
+         */
+        excludeVolumeTypes?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+    }
+    /**
+     * **[Custom snapshot policies only]** The rule for enabling fast snapshot restore.
+     */
+    interface LifecyclePolicyFastRestoreRuleArgs {
+        /**
+         * The Availability Zone IDs in which to enable fast snapshot restore.
+         */
+        availabilityZoneIds?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+        /**
+         * The Availability Zones in which to enable fast snapshot restore.
+         */
+        availabilityZones?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+        /**
+         * The number of snapshots to be enabled with fast snapshot restore.
+         */
+        count?: pulumi.Input<number | undefined>;
+        /**
+         * The amount of time to enable fast snapshot restore. The maximum is 100 years. This is equivalent to 1200 months, 5200 weeks, or 36500 days.
+         */
+        interval?: pulumi.Input<number | undefined>;
+        /**
+         * The unit of time for enabling fast snapshot restore.
+         */
+        intervalUnit?: pulumi.Input<string | undefined>;
+    }
+    /**
+     * **[Custom snapshot and AMI policies only]** A set of optional parameters for snapshot and AMI lifecycle policies.
+     */
+    interface LifecyclePolicyParametersArgs {
+        /**
+         * **[Custom snapshot policies that target instances only]** Indicates whether to exclude the root volume from multi-volume snapshot sets. The default is `false`. If you specify `true`, then the root volumes attached to targeted instances will be excluded from the multi-volume snapshot sets created by the policy.
+         */
+        excludeBootVolume?: pulumi.Input<boolean | undefined>;
+        /**
+         * **[Custom snapshot policies that target instances only]** The tags used to identify data (non-root) volumes to exclude from multi-volume snapshot sets. If you create a snapshot lifecycle policy that targets instances and you specify tags for this parameter, then data volumes with the specified tags that are attached to targeted instances will be excluded from the multi-volume snapshot sets created by the policy.
+         */
+        excludeDataVolumeTags?: pulumi.Input<pulumi.Input<inputs.dlm.LifecyclePolicyTagArgs>[] | undefined>;
+        /**
+         * **[Custom AMI policies only]** Indicates whether targeted instances are rebooted when the lifecycle policy runs. `true` indicates that targeted instances are not rebooted when the policy runs. `false` indicates that target instances are rebooted when the policy runs.
+         *
+         * The default is `true` (instances are not rebooted).
+         */
+        noReboot?: pulumi.Input<boolean | undefined>;
+    }
+    /**
+     * The configuration details of the lifecycle policy.
+     */
+    interface LifecyclePolicyPolicyDetailsArgs {
+        /**
+         * **[Event-based policies only]** The actions to be performed when the event-based policy is activated. You can specify only one action per policy.
+         */
+        actions?: pulumi.Input<pulumi.Input<inputs.dlm.LifecyclePolicyActionArgs>[] | undefined>;
+        /**
+         * **[Default policies only]** Indicates whether the policy should copy tags from the source resource to the snapshot or AMI. If you do not specify a value, the default is `false`.
+         *
+         * Default: `false`
+         */
+        copyTags?: pulumi.Input<boolean | undefined>;
+        /**
+         * **[Default policies only]** Specifies how often the policy should run and create snapshots or AMIs. The creation frequency can range from 1 to 7 days. If you do not specify a value, the default is 1.
+         *
+         * Default: 1
+         */
+        createInterval?: pulumi.Input<number | undefined>;
+        /**
+         * *[Default policies only]* Specifies destination Regions for snapshot or AMI copies. You can specify up to 3 destination Regions. If you do not want to create cross-Region copies, omit this parameter.
+         */
+        crossRegionCopyTargets?: pulumi.Input<pulumi.Input<inputs.dlm.LifecyclePolicyCrossRegionCopyTargetArgs>[] | undefined>;
+        /**
+         * *[Event-based policies only]* The event that activates the event-based policy.
+         */
+        eventSource?: pulumi.Input<inputs.dlm.LifecyclePolicyEventSourceArgs | undefined>;
+        /**
+         * *[Default policies only]* Specifies exclusion parameters for volumes or instances for which you do not want to create snapshots or AMIs. The policy will not create snapshots or AMIs for target resources that match any of the specified exclusion parameters.
+         */
+        exclusions?: pulumi.Input<inputs.dlm.LifecyclePolicyExclusionsArgs | undefined>;
+        /**
+         * **[Default policies only]** Defines the snapshot or AMI retention behavior for the policy if the source volume or instance is deleted, or if the policy enters the error, disabled, or deleted state.
+         *
+         * Default: `false`
+         */
+        extendDeletion?: pulumi.Input<boolean | undefined>;
+        /**
+         * *[Custom snapshot and AMI policies only]* A set of optional parameters for snapshot and AMI lifecycle policies.
+         *
+         * > If you are modifying a policy that was created or previously modified using the Amazon Data Lifecycle Manager console, then you must include this parameter and specify either the default values or the new values that you require. You can't omit this parameter or set its values to null.
+         */
+        parameters?: pulumi.Input<inputs.dlm.LifecyclePolicyParametersArgs | undefined>;
+        /**
+         * The type of policy to create. Specify one of the following:
+         *
+         * - `SIMPLIFIED` -- To create a default policy.
+         * - `STANDARD` -- To create a custom policy.
+         */
+        policyLanguage?: pulumi.Input<string | undefined>;
+        /**
+         * The type of policy. Specify `EBS_SNAPSHOT_MANAGEMENT` to create a lifecycle policy that manages the lifecycle of Amazon EBS snapshots. Specify `IMAGE_MANAGEMENT` to create a lifecycle policy that manages the lifecycle of EBS-backed AMIs. Specify `EVENT_BASED_POLICY` to create an event-based policy that performs specific actions when a defined event occurs in your AWS account.
+         *
+         * The default is `EBS_SNAPSHOT_MANAGEMENT`.
+         */
+        policyType?: pulumi.Input<string | undefined>;
+        /**
+         * **[Custom snapshot and AMI policies only]** The location of the resources to backup. If the source resources are located in a Region, specify `CLOUD`.
+         */
+        resourceLocations?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+        /**
+         * **[Default policies only]** Specify the type of default policy to create.
+         *
+         * - To create a default policy for EBS snapshots, that creates snapshots of all volumes in the Region that do not have recent backups, specify `VOLUME`.
+         * - To create a default policy for EBS-backed AMIs, that creates EBS-backed AMIs from all instances in the Region that do not have recent backups, specify `INSTANCE`.
+         */
+        resourceType?: pulumi.Input<string | undefined>;
+        /**
+         * **[Custom snapshot policies only]** The target resource type for snapshot and AMI lifecycle policies. Use `VOLUME` to create snapshots of individual volumes or use `INSTANCE` to create multi-volume snapshots from the volumes for an instance.
+         */
+        resourceTypes?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+        /**
+         * **[Default policies only]** Specifies how long the policy should retain snapshots or AMIs before deleting them. The retention period can range from 2 to 14 days, but it must be greater than the creation frequency to ensure that the policy retains at least 1 snapshot or AMI at any given time. If you do not specify a value, the default is 7.
+         *
+         * Default: 7
+         */
+        retainInterval?: pulumi.Input<number | undefined>;
+        /**
+         * **[Custom snapshot and AMI policies only]** The schedules of policy-defined actions for snapshot and AMI lifecycle policies. A policy can have up to four schedules -- one mandatory schedule and up to three optional schedules.
+         */
+        schedules?: pulumi.Input<pulumi.Input<inputs.dlm.LifecyclePolicyScheduleArgs>[] | undefined>;
+        /**
+         * **[Custom snapshot and AMI policies only]** The single tag that identifies targeted resources for this policy.
+         */
+        targetTags?: pulumi.Input<pulumi.Input<inputs.dlm.LifecyclePolicyTagArgs>[] | undefined>;
+    }
+    /**
+     * The retention rule for snapshots or AMIs created by the policy.
+     */
+    interface LifecyclePolicyRetainRuleArgs {
+        /**
+         * The number of snapshots to retain for each volume, up to a maximum of 1000. For example if you want to retain a maximum of three snapshots, specify `3`. When the fourth snapshot is created, the oldest retained snapshot is deleted, or it is moved to the archive tier if you have specified an `ArchiveRule`.
+         */
+        count?: pulumi.Input<number | undefined>;
+        /**
+         * The amount of time to retain each snapshot. The maximum is 100 years. This is equivalent to 1200 months, 5200 weeks, or 36500 days.
+         */
+        interval?: pulumi.Input<number | undefined>;
+        /**
+         * The unit of time for time-based retention. For example, to retain snapshots for 3 months, specify `Interval=3` and `IntervalUnit=MONTHS`. Once the snapshot has been retained for 3 months, it is deleted, or it is moved to the archive tier if you have specified an `ArchiveRule`.
+         */
+        intervalUnit?: pulumi.Input<string | undefined>;
+    }
+    /**
+     * Information about retention period in the Amazon EBS Snapshots Archive.
+     */
+    interface LifecyclePolicyRetentionArchiveTierArgs {
+        /**
+         * The maximum number of snapshots to retain in the archive storage tier for each volume. The count must ensure that each snapshot remains in the archive tier for at least 90 days.
+         */
+        count?: pulumi.Input<number | undefined>;
+        /**
+         * Specifies the period of time to retain snapshots in the archive tier. After this period expires, the snapshot is permanently deleted.
+         */
+        interval?: pulumi.Input<number | undefined>;
+        /**
+         * The unit of time in which to measure the **Interval**. For example, to retain snapshots in the archive tier for 6 months, specify `Interval=6` and `IntervalUnit=MONTHS`.
+         */
+        intervalUnit?: pulumi.Input<string | undefined>;
+    }
+    interface LifecyclePolicyScheduleArgs {
+        /**
+         * *[Custom snapshot policies that target volumes only]* The snapshot archiving rule for the schedule. When you specify an archiving rule, snapshots are automatically moved from the standard tier to the archive tier once the schedule's retention threshold is met. Snapshots are then retained in the archive tier for the archive retention period that you specify.
+         *
+         * For more information about using snapshot archiving, see [Considerations for snapshot lifecycle policies](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/snapshot-ami-policy.html#dlm-archive) .
+         */
+        archiveRule?: pulumi.Input<inputs.dlm.LifecyclePolicyArchiveRuleArgs | undefined>;
+        /**
+         * Copy all user-defined tags on a source volume to snapshots of the volume created by this policy.
+         */
+        copyTags?: pulumi.Input<boolean | undefined>;
+        /**
+         * The creation rule.
+         */
+        createRule?: pulumi.Input<inputs.dlm.LifecyclePolicyCreateRuleArgs | undefined>;
+        /**
+         * Specifies a rule for copying snapshots or AMIs across Regions.
+         */
+        crossRegionCopyRules?: pulumi.Input<pulumi.Input<inputs.dlm.LifecyclePolicyCrossRegionCopyRuleArgs>[] | undefined>;
+        /**
+         * *[Custom AMI policies only]* The AMI deprecation rule for the schedule.
+         */
+        deprecateRule?: pulumi.Input<inputs.dlm.LifecyclePolicyDeprecateRuleArgs | undefined>;
+        /**
+         * *[Custom snapshot policies only]* The rule for enabling fast snapshot restore.
+         */
+        fastRestoreRule?: pulumi.Input<inputs.dlm.LifecyclePolicyFastRestoreRuleArgs | undefined>;
+        /**
+         * The name of the schedule.
+         */
+        name?: pulumi.Input<string | undefined>;
+        /**
+         * The retention rule for snapshots or AMIs created by the policy.
+         */
+        retainRule?: pulumi.Input<inputs.dlm.LifecyclePolicyRetainRuleArgs | undefined>;
+        /**
+         * **[Custom snapshot policies only]** The rule for sharing snapshots with other AWS accounts.
+         */
+        shareRules?: pulumi.Input<pulumi.Input<inputs.dlm.LifecyclePolicyShareRuleArgs>[] | undefined>;
+        /**
+         * The tags to apply to policy-created resources. These user-defined tags are in addition to the AWS-added lifecycle tags.
+         */
+        tagsToAdd?: pulumi.Input<pulumi.Input<inputs.dlm.LifecyclePolicyTagArgs>[] | undefined>;
+        /**
+         * **[AMI policies and snapshot policies that target instances only]** A collection of key/value pairs with values determined dynamically when the policy is executed. Keys may be any valid Amazon EC2 tag key. Values must be in one of the two following formats: `$(instance-id)` or `$(timestamp)`. Variable tags are only valid for EBS Snapshot Management -- Instance policies.
+         */
+        variableTags?: pulumi.Input<pulumi.Input<inputs.dlm.LifecyclePolicyTagArgs>[] | undefined>;
+    }
+    interface LifecyclePolicyScriptArgs {
+        /**
+         * Indicates whether Amazon Data Lifecycle Manager should default to crash-consistent snapshots if the pre script fails.
+         *
+         * - To default to crash consistent snapshot if the pre script fails, specify `true`.
+         * - To skip the instance for snapshot creation if the pre script fails, specify `false`.
+         *
+         * This parameter is supported only if you run a pre script. If you run a post script only, omit this parameter.
+         *
+         * Default: `true`
+         */
+        executeOperationOnScriptFailure?: pulumi.Input<boolean | undefined>;
+        /**
+         * The SSM document that includes the pre and/or post scripts to run.
+         *
+         * If you are automating VSS backups, specify `AWS_VSS_BACKUP`. In this case, Amazon Data Lifecycle Manager automatically uses the `AWSEC2-CreateVssSnapshot` SSM document.
+         *
+         * If you are using a custom SSM document that you own, specify either the name or ARN of the SSM document. If you are using a custom SSM document that is shared with you, specify the ARN of the SSM document.
+         */
+        executionHandler?: pulumi.Input<string | undefined>;
+        /**
+         * Indicates the service used to execute the pre and/or post scripts.
+         *
+         * Default: `AWS_SYSTEMS_MANAGER`
+         */
+        executionHandlerService?: pulumi.Input<string | undefined>;
+        /**
+         * Specifies a timeout period, in seconds, after which Amazon Data Lifecycle Manager fails the script run attempt if it has not completed. If a script does not complete within its timeout period, Amazon Data Lifecycle Manager fails the attempt. The timeout period applies to the pre and post scripts individually.
+         *
+         * Default: 10
+         */
+        executionTimeout?: pulumi.Input<number | undefined>;
+        /**
+         * Specifies the number of times Amazon Data Lifecycle Manager should retry scripts that fail.
+         *
+         * If the pre script fails, Amazon Data Lifecycle Manager retries the entire snapshot creation process, including running the pre and post scripts.
+         *
+         * If the post script fails, Amazon Data Lifecycle Manager retries the post script only; in this case, the pre script will have completed and the snapshot might have been created.
+         *
+         * If you do not want Amazon Data Lifecycle Manager to retry failed scripts, specify `0`.
+         *
+         * Default: 0
+         */
+        maximumRetryCount?: pulumi.Input<number | undefined>;
+        /**
+         * Indicate which scripts Amazon Data Lifecycle Manager should run on target instances. Pre scripts run before Amazon Data Lifecycle Manager initiates snapshot creation. Post scripts run after Amazon Data Lifecycle Manager initiates snapshot creation.
+         *
+         * - To run a pre script only, specify `PRE`.
+         * - To run a post script only, specify `POST`.
+         * - To run both pre and post scripts, specify both `PRE` and `POST`.
+         *
+         * Default: PRE and POST
+         */
+        stages?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+    }
+    interface LifecyclePolicyShareRuleArgs {
+        /**
+         * The IDs of the AWS accounts with which to share the snapshots.
+         */
+        targetAccounts?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+        /**
+         * The period after which snapshots that are shared with other AWS accounts are automatically unshared.
+         */
+        unshareInterval?: pulumi.Input<number | undefined>;
+        /**
+         * The unit of time for the automatic unsharing interval.
+         */
+        unshareIntervalUnit?: pulumi.Input<string | undefined>;
+    }
+    interface LifecyclePolicyTagArgs {
+        /**
+         * The tag key.
+         */
+        key: pulumi.Input<string>;
+        /**
+         * The tag value.
+         */
+        value: pulumi.Input<string>;
+    }
+}
 export declare namespace dms {
     interface DataMigrationSettingsArgs {
         /**
@@ -33054,6 +33655,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?: pulumi.Input<inputs.dynamodb.GlobalTableResourcePolicyArgs | undefined>;
+        tags?: pulumi.Input<pulumi.Input<inputs.dynamodb.GlobalTableTagArgs>[] | undefined>;
     }
     interface GlobalTableResourcePolicyArgs {
         /**
@@ -33452,6 +34054,22 @@ export declare namespace dynamodb {
          *   +  ``NEW_AND_OLD_IMAGES`` - Both the new and the old item images of the item are written to the stream.
          */
         streamViewType: pulumi.Input<string>;
+        tags?: pulumi.Input<pulumi.Input<inputs.dynamodb.TableTagArgs>[] | undefined>;
+    }
+    /**
+     * Describes a tag. A tag is a key-value pair. You can add up to 50 tags to a single DynamoDB table.
+     *  AWS-assigned tag names and values are automatically assigned the ``aws:`` prefix, which the user cannot assign. AWS-assigned tag names do not count towards the tag limit of 50. User-assigned tag names have the prefix ``user:`` in the Cost Allocation Report. You cannot backdate the application of a tag.
+     *  For an overview on tagging DynamoDB resources, see [Tagging for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html) in the *Amazon DynamoDB Developer Guide*.
+     */
+    interface TableTagArgs {
+        /**
+         * The key of the tag. Tag keys are case sensitive. Each DynamoDB table can only have up to one tag with the same key. If you try to add an existing tag (same key), the existing tag value will be updated to the new value.
+         */
+        key: pulumi.Input<string>;
+        /**
+         * The value of the tag. Tag values are case-sensitive and can be null.
+         */
+        value: pulumi.Input<string>;
     }
     /**
      * Represents the settings used to enable or disable Time to Live (TTL) for the specified table.
@@ -33483,6 +34101,18 @@ export declare namespace dynamodb {
     }
 }
 export declare namespace ec2 {
+    interface ApplicationStatusCheckHealthCheckPathArgs {
+        destinations?: pulumi.Input<pulumi.Input<inputs.ec2.ApplicationStatusCheckHealthCheckPathDestinationArgs>[] | undefined>;
+        source?: pulumi.Input<inputs.ec2.ApplicationStatusCheckHealthCheckPathSourceArgs | undefined>;
+    }
+    interface ApplicationStatusCheckHealthCheckPathDestinationArgs {
+        securityGroupId?: pulumi.Input<string | undefined>;
+        subnetId?: pulumi.Input<string | undefined>;
+    }
+    interface ApplicationStatusCheckHealthCheckPathSourceArgs {
+        securityGroupId?: pulumi.Input<string | undefined>;
+        subnetId?: pulumi.Input<string | undefined>;
+    }
     interface CapacityReservationFleetInstanceTypeSpecificationArgs {
         /**
          * The Availability Zone in which the Capacity Reservation Fleet reserves the capacity. A Capacity Reservation Fleet can't span Availability Zones. All instance type specifications that you specify for the Fleet must use the same Availability Zone.
@@ -33688,6 +34318,10 @@ export declare namespace ec2 {
          */
         usageStrategy?: pulumi.Input<enums.ec2.Ec2FleetCapacityReservationOptionsRequestUsageStrategy | undefined>;
     }
+    interface Ec2FleetCapacityReservationTargetRequestArgs {
+        capacityReservationIds?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+        capacityReservationResourceGroupArns?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+    }
     interface Ec2FleetCpuPerformanceFactorRequestArgs {
         /**
          * Specify an instance family to use as the baseline reference for CPU performance. All instance types that match your specified attributes will be compared against the CPU performance of the referenced instance family, regardless of CPU manufacturer or architecture differences.
@@ -34307,8 +34941,14 @@ export declare namespace ec2 {
         primary?: pulumi.Input<boolean | undefined>;
         privateIpAddress?: pulumi.Input<string | undefined>;
     }
+    interface Ec2FleetReservedCapacityFallbackOptionsRequestArgs {
+        marketTypes?: pulumi.Input<pulumi.Input<enums.ec2.Ec2FleetReservedCapacityFallbackOptionsRequestMarketTypesItem>[] | undefined>;
+    }
     interface Ec2FleetReservedCapacityOptionsRequestArgs {
+        allocationStrategy?: pulumi.Input<enums.ec2.Ec2FleetReservedCapacityOptionsRequestAllocationStrategy | undefined>;
+        capacityReservationTarget?: pulumi.Input<inputs.ec2.Ec2FleetCapacityReservationTargetRequestArgs | undefined>;
         reservationTypes?: pulumi.Input<pulumi.Input<enums.ec2.Ec2FleetReservedCapacityOptionsRequestReservationTypesItem>[] | undefined>;
+        reservedCapacityFallbackOptions?: pulumi.Input<inputs.ec2.Ec2FleetReservedCapacityFallbackOptionsRequestArgs | undefined>;
     }
     interface Ec2FleetSpotOptionsRequestArgs {
         /**
@@ -41498,6 +42138,19 @@ export declare namespace eks {
          */
         serviceAccount: pulumi.Input<string>;
     }
+    /**
+     * Configuration settings for an ACK (AWS Controllers for Kubernetes) capability.
+     */
+    interface CapabilityAckArgs {
+        /**
+         * A list of ACK service names to disable. Controllers for services in this list are not installed or managed.
+         */
+        disabledServices?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+        /**
+         * Whether cross-namespace references are enabled for ACK controllers. When not specified, the service default applies.
+         */
+        enableCrossNamespace?: pulumi.Input<boolean | undefined>;
+    }
     /**
      * Configuration settings for an Argo CD capability. This includes the Kubernetes namespace, IAM Identity Center integration, RBAC role mappings, and network access configuration.
      */
@@ -41551,7 +42204,7 @@ export declare namespace eks {
      * Configuration settings for a capability. The structure of this object varies depending on the capability type.
      */
     interface CapabilityConfigurationArgs {
-        ack?: any | undefined;
+        ack?: pulumi.Input<inputs.eks.CapabilityAckArgs | undefined>;
         argoCd?: pulumi.Input<inputs.eks.CapabilityArgoCdArgs | undefined>;
     }
     /**
@@ -41715,6 +42368,7 @@ export declare namespace eks {
      */
     interface ClusterKubeControllerManagerConfigArgs {
         horizontalPodAutoscalerControllerConfig?: pulumi.Input<inputs.eks.ClusterHorizontalPodAutoscalerControllerConfigArgs | undefined>;
+        podGcControllerConfig?: pulumi.Input<inputs.eks.ClusterPodGcControllerConfigArgs | undefined>;
     }
     /**
      * The configuration for the Kubernetes scheduler on an Amazon EKS cluster.
@@ -41794,6 +42448,15 @@ export declare namespace eks {
          */
         outpostArns: pulumi.Input<pulumi.Input<string>[]>;
     }
+    /**
+     * The pod garbage collector controller configuration.
+     */
+    interface ClusterPodGcControllerConfigArgs {
+        /**
+         * The number of terminated pods that can exist before the terminated pod garbage collector starts deleting them.
+         */
+        terminatedPodGcThreshold?: pulumi.Input<number | undefined>;
+    }
     interface ClusterProviderArgs {
         /**
          * Amazon Resource Name (ARN) or alias of the KMS key. The KMS key must be symmetric, created in the same region as the cluster, and if the KMS key was created in a different account, the user must have access to the KMS key.
@@ -43604,7 +44267,13 @@ export declare namespace elementalinference {
     interface FeedCroppingConfigArgs {
         templateGroups?: pulumi.Input<pulumi.Input<inputs.elementalinference.FeedTemplateGroupArgs>[] | undefined>;
     }
+    /**
+     * Identifies the fixture whose event data Elemental Inference maps onto the clipping metadata for an output.
+     */
     interface FeedDataSourceConfigurationArgs {
+        /**
+         * The ID of the fixture whose event data you want Elemental Inference to map onto this clipping output. To obtain this ID, use the SearchFixtures operation.
+         */
         fixtureId: pulumi.Input<string>;
     }
     interface FeedGetOutputArgs {
@@ -46545,6 +47214,229 @@ export declare namespace fsx {
          */
         vpcId: pulumi.Input<string>;
     }
+    interface VolumeAggregateConfigurationArgs {
+        /**
+         * The list of aggregates that this volume resides on. Aggregates are storage pools which make up your primary storage tier.
+         */
+        aggregates?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+        /**
+         * Used to explicitly set the number of constituents within the FlexGroup per storage aggregate. This field is optional when creating a FlexGroup volume. If unspecified, the default value will be 8. This field cannot be provided when creating a FlexVol volume.
+         */
+        constituentsPerAggregate?: pulumi.Input<number | undefined>;
+    }
+    interface VolumeAutocommitPeriodArgs {
+        /**
+         * Defines the type of time for the autocommit period of a file in an FSx for ONTAP SnapLock volume. Setting this value to NONE disables autocommit. The default value is NONE.
+         */
+        type: pulumi.Input<string>;
+        /**
+         * Defines the amount of time for the autocommit period of a file in an FSx for ONTAP SnapLock volume.
+         */
+        value?: pulumi.Input<number | undefined>;
+    }
+    interface VolumeClientConfigurationsArgs {
+        /**
+         * A value that specifies who can mount the file system. You can provide a wildcard character (*), an IP address (0.0.0.0), or a CIDR address (192.0.2.0/24). By default, Amazon FSx uses the wildcard character when specifying the client.
+         */
+        clients: pulumi.Input<string>;
+        /**
+         * The configuration object for mounting a Network File System (NFS) file system.
+         */
+        options: pulumi.Input<pulumi.Input<string>[]>;
+    }
+    interface VolumeNfsExportsArgs {
+        /**
+         * The configuration object for mounting a Network File System (NFS) file system.
+         */
+        clientConfigurations: pulumi.Input<pulumi.Input<inputs.fsx.VolumeClientConfigurationsArgs>[]>;
+    }
+    interface VolumeOntapConfigurationArgs {
+        /**
+         * Used to specify the configuration options for an FSx for ONTAP volume's storage aggregate or aggregates.
+         */
+        aggregateConfiguration?: pulumi.Input<inputs.fsx.VolumeAggregateConfigurationArgs | undefined>;
+        /**
+         * A boolean flag indicating whether tags for the volume should be copied to backups.
+         */
+        copyTagsToBackups?: pulumi.Input<string | undefined>;
+        /**
+         * Specifies the location in the SVM's namespace where the volume is mounted. This parameter is required. The JunctionPath must have a leading forward slash, such as /vol3.
+         */
+        junctionPath?: pulumi.Input<string | undefined>;
+        /**
+         * Specifies the type of volume you are creating. Valid values are the following: RW or DP
+         */
+        ontapVolumeType?: pulumi.Input<string | undefined>;
+        /**
+         * Specifies the security style for the volume. If a volume's security style is not specified, it is automatically set to the root volume's security style.
+         */
+        securityStyle?: pulumi.Input<string | undefined>;
+        /**
+         * Specifies the configured size of the volume, in bytes.
+         */
+        sizeInBytes?: pulumi.Input<string | undefined>;
+        /**
+         * Use SizeInBytes instead. Specifies the size of the volume, in megabytes (MB), that you are creating
+         */
+        sizeInMegabytes?: pulumi.Input<string | undefined>;
+        /**
+         * The SnapLock configuration object for an FSx for ONTAP SnapLock volume.
+         */
+        snaplockConfiguration?: pulumi.Input<inputs.fsx.VolumeSnaplockConfigurationArgs | undefined>;
+        /**
+         * Specifies the snapshot policy for the volume. There are three built-in snapshot policies: default, default-1weekly, none.
+         */
+        snapshotPolicy?: pulumi.Input<string | undefined>;
+        /**
+         * Set to true to enable deduplication, compression, and compaction storage efficiency features on the volume, or set to false to disable them.
+         */
+        storageEfficiencyEnabled?: pulumi.Input<string | undefined>;
+        /**
+         * Specifies the ONTAP SVM in which to create the volume.
+         */
+        storageVirtualMachineId: pulumi.Input<string>;
+        /**
+         * Describes the data tiering policy for an ONTAP volume.
+         */
+        tieringPolicy?: pulumi.Input<inputs.fsx.VolumeTieringPolicyArgs | undefined>;
+        /**
+         * Use to specify the style of an ONTAP volume.
+         */
+        volumeStyle?: pulumi.Input<string | undefined>;
+    }
+    interface VolumeOpenZfsConfigurationArgs {
+        /**
+         * A Boolean value indicating whether tags for the volume should be copied to snapshots. This value defaults to false. If this value is set to true, and you do not specify any tags, all tags for the original volume are copied over to snapshots. If this value is set to true, and you do specify one or more tags, only the specified tags for the original volume are copied over to snapshots. If you specify one or more tags when creating a new snapshot, no tags are copied over from the original volume, regardless of this value.
+         */
+        copyTagsToSnapshots?: pulumi.Input<boolean | undefined>;
+        /**
+         * Specifies the method used to compress the data on the volume
+         */
+        dataCompressionType?: pulumi.Input<string | undefined>;
+        /**
+         * The configuration object for mounting a Network File System (NFS) file system.
+         */
+        nfsExports?: pulumi.Input<pulumi.Input<inputs.fsx.VolumeNfsExportsArgs>[] | undefined>;
+        /**
+         * The configuration object for mounting a Network File System (NFS) file system.
+         */
+        options?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+        /**
+         * The configuration of an Amazon FSx for OpenZFS volume.
+         */
+        originSnapshot?: pulumi.Input<inputs.fsx.VolumeOriginSnapshotArgs | undefined>;
+        /**
+         * The ID of the volume to use as the parent volume of the volume that you are creating.
+         */
+        parentVolumeId: pulumi.Input<string>;
+        /**
+         * A Boolean value indicating whether the volume is read-only.
+         */
+        readOnly?: pulumi.Input<boolean | undefined>;
+        /**
+         * Specifies the suggested block size for a volume in a ZFS dataset, in kibibytes (KiB).
+         */
+        recordSizeKiB?: pulumi.Input<number | undefined>;
+        /**
+         * Sets the maximum storage size in gibibytes (GiB) for the volume. You can specify a quota that is larger than the storage on the parent volume. A volume quota limits the amount of storage that the volume can consume to the configured amount, but does not guarantee the space will be available on the parent volume. To guarantee quota space, you must also set StorageCapacityReservationGiB. To not specify a storage capacity quota, set this to -1.
+         */
+        storageCapacityQuotaGiB?: pulumi.Input<number | undefined>;
+        /**
+         * Specifies the amount of storage in gibibytes (GiB) to reserve from the parent volume. Setting StorageCapacityReservationGiB guarantees that the specified amount of storage space on the parent volume will always be available for the volume. You can't reserve more storage than the parent volume has. To not specify a storage capacity reservation, set this to 0 or -1. For more information, see Volume properties in the Amazon FSx for OpenZFS User Guide.
+         */
+        storageCapacityReservationGiB?: pulumi.Input<number | undefined>;
+        /**
+         * Configures how much storage users and groups can use on the volume.
+         */
+        userAndGroupQuotas?: pulumi.Input<pulumi.Input<inputs.fsx.VolumeUserAndGroupQuotasArgs>[] | undefined>;
+    }
+    interface VolumeOriginSnapshotArgs {
+        /**
+         * The configuration object for mounting a Network File System (NFS) file system.
+         */
+        copyStrategy: pulumi.Input<string>;
+        /**
+         * Specifies the snapshot to use when creating an OpenZFS volume from a snapshot.
+         */
+        snapshotArn: pulumi.Input<string>;
+    }
+    interface VolumeRetentionPeriodArgs {
+        /**
+         * Defines the type of time for the retention period of an FSx for ONTAP SnapLock volume. Set it to one of the valid types. If you set it to INFINITE, the files are retained forever. If you set it to UNSPECIFIED, the files are retained until you set an explicit retention period.
+         */
+        type: pulumi.Input<string>;
+        /**
+         * Defines the amount of time for the retention period of an FSx for ONTAP SnapLock volume. You can't set a value for INFINITE or UNSPECIFIED.
+         */
+        value?: pulumi.Input<number | undefined>;
+    }
+    interface VolumeSnaplockConfigurationArgs {
+        /**
+         * Enables or disables the audit log volume for an FSx for ONTAP SnapLock volume
+         */
+        auditLogVolume?: pulumi.Input<string | undefined>;
+        /**
+         * The configuration object for setting the autocommit period of files in an FSx for ONTAP SnapLock volume.
+         */
+        autocommitPeriod?: pulumi.Input<inputs.fsx.VolumeAutocommitPeriodArgs | undefined>;
+        /**
+         * Enables, disables, or permanently disables privileged delete on an FSx for ONTAP SnapLock Enterprise volume.
+         */
+        privilegedDelete?: pulumi.Input<string | undefined>;
+        /**
+         * Specifies the retention period of an FSx for ONTAP SnapLock volume.
+         */
+        retentionPeriod?: pulumi.Input<inputs.fsx.VolumeSnaplockRetentionPeriodArgs | undefined>;
+        /**
+         * Specifies the retention mode of an FSx for ONTAP SnapLock volume. After it is set, it can't be changed.
+         */
+        snaplockType: pulumi.Input<string>;
+        /**
+         * Enables or disables volume-append mode on an FSx for ONTAP SnapLock volume.
+         */
+        volumeAppendModeEnabled?: pulumi.Input<string | undefined>;
+    }
+    interface VolumeSnaplockRetentionPeriodArgs {
+        /**
+         * The retention period assigned to a write once, read many (WORM) file by default if an explicit retention period is not set for an FSx for ONTAP SnapLock volume.
+         */
+        defaultRetention: pulumi.Input<inputs.fsx.VolumeRetentionPeriodArgs>;
+        /**
+         * The longest retention period that can be assigned to a WORM file on an FSx for ONTAP SnapLock volume.
+         */
+        maximumRetention: pulumi.Input<inputs.fsx.VolumeRetentionPeriodArgs>;
+        /**
+         * The shortest retention period that can be assigned to a WORM file on an FSx for ONTAP SnapLock volume.
+         */
+        minimumRetention: pulumi.Input<inputs.fsx.VolumeRetentionPeriodArgs>;
+    }
+    /**
+     * Describes the data tiering policy for an ONTAP volume. When enabled, Amazon FSx for ONTAP's intelligent tiering automatically transitions a volume's data between the file system's primary storage and capacity pool storage based on your access patterns.
+     */
+    interface VolumeTieringPolicyArgs {
+        /**
+         * Specifies the number of days that user data in a volume must remain inactive before it is considered "cold" and moved to the capacity pool.
+         */
+        coolingPeriod?: pulumi.Input<number | undefined>;
+        /**
+         * Specifies the tiering policy used to transition data. Default value is SNAPSHOT_ONLY.
+         */
+        name?: pulumi.Input<string | undefined>;
+    }
+    interface VolumeUserAndGroupQuotasArgs {
+        /**
+         * The ID of the user or group that the quota applies to.
+         */
+        id: pulumi.Input<number>;
+        /**
+         * The user or group's storage quota, in gibibytes (GiB).
+         */
+        storageCapacityQuotaGiB: pulumi.Input<number>;
+        /**
+         * Specifies whether the quota applies to a user or group.
+         */
+        type: pulumi.Input<string>;
+    }
 }
 export declare namespace gamelift {
     interface AliasRoutingStrategyArgs {
@@ -52367,6 +53259,7 @@ export declare namespace iot {
          * Send data to an HTTPS endpoint.
          */
         http?: pulumi.Input<inputs.iot.TopicRuleHttpActionArgs | undefined>;
+        influxDb?: pulumi.Input<inputs.iot.TopicRuleInfluxDbActionArgs | undefined>;
         /**
          * Sends message data to an AWS IoT Analytics channel.
          */
@@ -52536,6 +53429,28 @@ export declare namespace iot {
          */
         confirmationUrl?: pulumi.Input<string | undefined>;
     }
+    interface TopicRuleDestinationInfluxDbDestinationPropertiesArgs {
+        /**
+         * The endpoint URL of the InfluxDB database.
+         */
+        endpoint: pulumi.Input<string>;
+        /**
+         * The version of the InfluxDB database (for example, V2 or V3).
+         */
+        influxDbVersion: pulumi.Input<string>;
+        /**
+         * The ARN or name of the Secrets Manager secret containing the InfluxDB API token.
+         */
+        secretId: pulumi.Input<string>;
+        /**
+         * The key name within the secret that contains the InfluxDB token.
+         */
+        secretKey?: pulumi.Input<string | undefined>;
+        /**
+         * The type of the secret value (SecretString or SecretBinary).
+         */
+        secretType?: pulumi.Input<string | undefined>;
+    }
     interface TopicRuleDestinationVpcDestinationPropertiesArgs {
         /**
          * The ARN of a role that has permission to create and attach to elastic network interfaces (ENIs).
@@ -52684,6 +53599,24 @@ export declare namespace iot {
          */
         sigv4?: pulumi.Input<inputs.iot.TopicRuleSigV4AuthorizationArgs | undefined>;
     }
+    interface TopicRuleInfluxDbActionArgs {
+        batchConfig?: pulumi.Input<inputs.iot.TopicRuleInfluxDbBatchConfigArgs | undefined>;
+        databaseName: pulumi.Input<string>;
+        destinationArn: pulumi.Input<string>;
+        organization?: pulumi.Input<string | undefined>;
+        roleArn: pulumi.Input<string>;
+        tableName: pulumi.Input<string>;
+        tags?: pulumi.Input<{
+            [key: string]: pulumi.Input<string>;
+        } | undefined>;
+        timestampUnit?: pulumi.Input<string | undefined>;
+    }
+    interface TopicRuleInfluxDbBatchConfigArgs {
+        batchAcrossTopics?: pulumi.Input<boolean | undefined>;
+        maxBatchOpenMs?: pulumi.Input<number | undefined>;
+        maxBatchSize?: pulumi.Input<number | undefined>;
+        maxBatchSizeBytes?: pulumi.Input<number | undefined>;
+    }
     interface TopicRuleIotAnalyticsActionArgs {
         /**
          * Whether to process the action as a batch. The default value is `false` .
@@ -59435,6 +60368,7 @@ export declare namespace lakeformation {
         filterExpression?: pulumi.Input<string | undefined>;
     }
     interface PrincipalPermissionsCatalogResourceArgs {
+        id?: pulumi.Input<string | undefined>;
     }
     /**
      * A wildcard object, consisting of an optional list of excluded column names or indexes.
@@ -64580,6 +65514,12 @@ export declare namespace mediaconnect {
      */
     interface RouterOutputResourceDefaultMaintenanceConfigurationArgs {
     }
+    /**
+     * The fabric configuration settings for the router output.
+     */
+    interface RouterOutputResourceFabricConfigurationArgs {
+        recoveryLatencyMode: pulumi.Input<enums.mediaconnect.RouterOutputResourceFabricLatencyMode>;
+    }
     /**
      * The configuration that defines how content is encrypted during transit between the MediaConnect router and a MediaConnect flow.
      */
@@ -68004,6 +68944,17 @@ export declare namespace mwaa {
     }
 }
 export declare namespace mwaaserverless {
+    /**
+     * The location of code artifacts in Amazon S3 for the workflow. Modeled as a single-member container so it stays extensible to future artifact types (e.g. OCI images).
+     */
+    interface WorkflowCodeArgs {
+        s3Location?: pulumi.Input<inputs.mwaaserverless.WorkflowCodeS3LocationArgs | undefined>;
+    }
+    interface WorkflowCodeS3LocationArgs {
+        bucket: pulumi.Input<string>;
+        objectKey: pulumi.Input<string>;
+        versionId?: pulumi.Input<string | undefined>;
+    }
     interface WorkflowEncryptionConfigurationArgs {
         kmsKeyId?: pulumi.Input<string | undefined>;
         type: pulumi.Input<enums.mwaaserverless.WorkflowEncryptionConfigurationType>;
@@ -103031,6 +103982,8 @@ export declare namespace rds {
          * The upper limit in gibibytes (GiB) to which RDS can automatically scale the storage of the additional storage volume.
          */
         maxAllocatedStorage?: pulumi.Input<number | undefined>;
+        storageOperationPercentProgress?: pulumi.Input<number | undefined>;
+        storageOperationStatus?: pulumi.Input<string | undefined>;
         /**
          * The storage throughput value for the additional storage volume, in mebibytes per second (MiBps). This setting applies only to the General Purpose SSD (``gp3``) storage type.
          */
@@ -107769,6 +108722,27 @@ export declare namespace sagemaker {
          */
         value: pulumi.Input<string>;
     }
+    /**
+     * External MySQL-compatible accounting database that a Slurm cluster's slurmdbd connects to. Database credentials are supplied out-of-band through the referenced Secrets Manager secret. Supported only with Continuous node provisioning.
+     */
+    interface ClusterAccountingDatabaseArgs {
+        /**
+         * Hostname or endpoint of the accounting database, such as an RDS endpoint.
+         */
+        endpoint: pulumi.Input<string>;
+        /**
+         * Name of the accounting database schema. Defaults to slurm_acct_db when omitted.
+         */
+        name?: pulumi.Input<string | undefined>;
+        /**
+         * TCP port of the accounting database. Defaults to 3306 when omitted.
+         */
+        port?: pulumi.Input<number | undefined>;
+        /**
+         * ARN of the Secrets Manager secret holding the database credentials.
+         */
+        secretArn: pulumi.Input<string>;
+    }
     /**
      * The details of the alarm to monitor during the AMI update.
      */
@@ -108027,6 +109001,7 @@ export declare namespace sagemaker {
      * Specifies parameter(s) related to Slurm as orchestrator.
      */
     interface ClusterOrchestratorSlurmConfigArgs {
+        accountingDatabase?: pulumi.Input<inputs.sagemaker.ClusterAccountingDatabaseArgs | undefined>;
         /**
          * The strategy for managing Slurm configuration on the cluster.
          */
@@ -108998,6 +109973,471 @@ export declare namespace sagemaker {
          */
         value: pulumi.Input<number>;
     }
+    /**
+     * Configures the behavior of the client used by SageMaker to interact with the model container during asynchronous inference.
+     */
+    interface EndpointConfigAsyncInferenceClientConfigArgs {
+        /**
+         * The maximum number of concurrent requests sent by the SageMaker client to the model container. If no value is provided, SageMaker will choose an optimal value for you.
+         */
+        maxConcurrentInvocationsPerInstance?: pulumi.Input<number | undefined>;
+    }
+    /**
+     * Specifies configuration for how an endpoint performs asynchronous inference.
+     */
+    interface EndpointConfigAsyncInferenceConfigArgs {
+        /**
+         * Configures the behavior of the client used by SageMaker to interact with the model container during asynchronous inference.
+         */
+        clientConfig?: pulumi.Input<inputs.sagemaker.EndpointConfigAsyncInferenceClientConfigArgs | undefined>;
+        /**
+         * Specifies the configuration for asynchronous inference invocation outputs.
+         */
+        outputConfig: pulumi.Input<inputs.sagemaker.EndpointConfigAsyncInferenceOutputConfigArgs>;
+    }
+    /**
+     * Specifies the configuration for notifications of inference results for asynchronous inference.
+     */
+    interface EndpointConfigAsyncInferenceNotificationConfigArgs {
+        /**
+         * Amazon SNS topic to post a notification to when an inference fails. If no topic is provided, no notification is sent on failure.
+         */
+        errorTopic?: pulumi.Input<string | undefined>;
+        /**
+         * The Amazon SNS topics where you want the inference response to be included.
+         */
+        includeInferenceResponseIn?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+        /**
+         * Amazon SNS topic to post a notification to when an inference completes successfully. If no topic is provided, no notification is sent on success.
+         */
+        successTopic?: pulumi.Input<string | undefined>;
+    }
+    /**
+     * Specifies the configuration for asynchronous inference invocation outputs.
+     */
+    interface EndpointConfigAsyncInferenceOutputConfigArgs {
+        /**
+         * The AWS Key Management Service (AWS KMS) key that Amazon SageMaker uses to encrypt the asynchronous inference output in Amazon S3.
+         */
+        kmsKeyId?: pulumi.Input<string | undefined>;
+        /**
+         * Specifies the configuration for notifications of inference results for asynchronous inference.
+         */
+        notificationConfig?: pulumi.Input<inputs.sagemaker.EndpointConfigAsyncInferenceNotificationConfigArgs | undefined>;
+        /**
+         * The Amazon S3 location to upload failure inference responses to.
+         */
+        s3FailurePath?: pulumi.Input<string | undefined>;
+        /**
+         * The Amazon S3 location to upload inference responses to.
+         */
+        s3OutputPath?: pulumi.Input<string | undefined>;
+    }
+    /**
+     * Settings for the capacity reservation for the compute instances that SageMaker AI reserves for an endpoint.
+     */
+    interface EndpointConfigCapacityReservationConfigArgs {
+        /**
+         * Options that you can choose for the capacity reservation.
+         */
+        capacityReservationPreference?: pulumi.Input<string | undefined>;
+        /**
+         * The Amazon Resource Name (ARN) that uniquely identifies the ML capacity reservation that SageMaker AI applies when it deploys the endpoint.
+         */
+        mlReservationArn?: pulumi.Input<string | undefined>;
+    }
+    /**
+     * Specifies the JSON and CSV content types of the data that the endpoint captures.
+     */
+    interface EndpointConfigCaptureContentTypeHeaderArgs {
+        /**
+         * A list of the CSV content types of the data that the endpoint captures. For the endpoint to capture the data, you must also specify the content type when you invoke the endpoint.
+         */
+        csvContentTypes?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+        /**
+         * A list of the JSON content types of the data that the endpoint captures. For the endpoint to capture the data, you must also specify the content type when you invoke the endpoint.
+         */
+        jsonContentTypes?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+    }
+    /**
+     * Specifies whether the endpoint captures input data or output data.
+     */
+    interface EndpointConfigCaptureOptionArgs {
+        /**
+         * Specifies whether the endpoint captures input data or output data.
+         */
+        captureMode: pulumi.Input<string>;
+    }
+    /**
+     * The configuration parameters for the SageMaker Clarify explainer.
+     */
+    interface EndpointConfigClarifyExplainerConfigArgs {
+        /**
+         * A JMESPath boolean expression used to filter which records to explain. Explanations are activated by default.
+         */
+        enableExplanations?: pulumi.Input<string | undefined>;
+        /**
+         * The inference configuration parameter for the model container.
+         */
+        inferenceConfig?: pulumi.Input<inputs.sagemaker.EndpointConfigClarifyInferenceConfigArgs | undefined>;
+        /**
+         * The configuration for SHAP analysis.
+         */
+        shapConfig: pulumi.Input<inputs.sagemaker.EndpointConfigClarifyShapConfigArgs>;
+    }
+    /**
+     * The inference configuration parameter for the model container.
+     */
+    interface EndpointConfigClarifyInferenceConfigArgs {
+        /**
+         * A template string used to format a JSON record into an acceptable model container input.
+         */
+        contentTemplate?: pulumi.Input<string | undefined>;
+        /**
+         * The names of the features. If provided, these are included in the endpoint response payload to help readability of the InvokeEndpoint output.
+         */
+        featureHeaders?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+        /**
+         * A list of data types of the features (optional). Applicable only to NLP explainability. If provided, FeatureTypes must have at least one 'text' string (for example, ['text']). If FeatureTypes is not provided, the explainer infers the feature types based on the baseline data.
+         */
+        featureTypes?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+        /**
+         * Provides the JMESPath expression to extract the features from a model container input in JSON Lines format.
+         */
+        featuresAttribute?: pulumi.Input<string | undefined>;
+        /**
+         * A JMESPath expression used to locate the list of label headers in the model container output.
+         */
+        labelAttribute?: pulumi.Input<string | undefined>;
+        /**
+         * For multiclass classification problems, the label headers are the names of the classes. Otherwise, the label header is the name of the predicted label.
+         */
+        labelHeaders?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+        /**
+         * A zero-based index used to extract a label header or list of label headers from model container output in CSV format.
+         */
+        labelIndex?: pulumi.Input<number | undefined>;
+        /**
+         * The maximum payload size (MB) allowed of a request from the explainer to the model container. Defaults to 6 MB.
+         */
+        maxPayloadInMb?: pulumi.Input<number | undefined>;
+        /**
+         * The maximum number of records in a request that the model container can process when querying the model container for the predictions of a synthetic dataset. A record is a unit of input data that inference can be made on, for example, a single line in CSV data.
+         */
+        maxRecordCount?: pulumi.Input<number | undefined>;
+        /**
+         * A JMESPath expression used to extract the probability (or score) from the model container output if the model container is in JSON Lines format.
+         */
+        probabilityAttribute?: pulumi.Input<string | undefined>;
+        /**
+         * A zero-based index used to extract a probability value (score) or list from model container output in CSV format. If this value is not provided, the entire model container output will be treated as a probability value (score) or list.
+         */
+        probabilityIndex?: pulumi.Input<number | undefined>;
+    }
+    /**
+     * The configuration for the SHAP baseline (also called the background or reference dataset) of the Kernal SHAP algorithm.
+     */
+    interface EndpointConfigClarifyShapBaselineConfigArgs {
+        /**
+         * The MIME type of the baseline data. Choose from 'text/csv' or 'application/jsonlines'. Defaults to 'text/csv'.
+         */
+        mimeType?: pulumi.Input<string | undefined>;
+        /**
+         * The inline SHAP baseline data in string format. ShapBaseline can have one or multiple records to be used as the baseline dataset. The format of the SHAP baseline file should be the same format as the training dataset.
+         */
+        shapBaseline?: pulumi.Input<string | undefined>;
+        /**
+         * The uniform resource identifier (URI) of the S3 bucket where the SHAP baseline file is stored. The format of the SHAP baseline file should be the same format as the format of the training dataset.
+         */
+        shapBaselineUri?: pulumi.Input<string | undefined>;
+    }
+    /**
+     * The configuration for SHAP analysis using SageMaker Clarify Explainer.
+     */
+    interface EndpointConfigClarifyShapConfigArgs {
+        /**
+         * The number of samples to be used for analysis by the Kernal SHAP algorithm.
+         */
+        numberOfSamples?: pulumi.Input<number | undefined>;
+        /**
+         * The starting value used to initialize the random number generator in the explainer. Provide a value for this parameter to obtain a deterministic SHAP result.
+         */
+        seed?: pulumi.Input<number | undefined>;
+        /**
+         * The configuration for the SHAP baseline of the Kernal SHAP algorithm.
+         */
+        shapBaselineConfig: pulumi.Input<inputs.sagemaker.EndpointConfigClarifyShapBaselineConfigArgs>;
+        /**
+         * A parameter that indicates if text features are treated as text and explanations are provided for individual units of text. Required for natural language processing (NLP) explainability only.
+         */
+        textConfig?: pulumi.Input<inputs.sagemaker.EndpointConfigClarifyTextConfigArgs | undefined>;
+        /**
+         * A Boolean toggle to indicate if you want to use the logit function (true) or log-odds units (false) for model predictions. Defaults to false.
+         */
+        useLogit?: pulumi.Input<boolean | undefined>;
+    }
+    /**
+     * A parameter used to configure the SageMaker Clarify explainer to treat text features as text so that explanations are provided for individual units of text. Required only for natural language processing (NLP) explainability.
+     */
+    interface EndpointConfigClarifyTextConfigArgs {
+        /**
+         * The unit of granularity for the analysis of text features. For example, if the unit is 'token', then each token (like a word in English) of the text is treated as a feature. SHAP values are computed for each unit/feature.
+         */
+        granularity: pulumi.Input<string>;
+        /**
+         * Specifies the language of the text features in ISO 639-1 or ISO 639-3 code of a supported language.
+         */
+        language: pulumi.Input<string>;
+    }
+    /**
+     * Specifies where SageMaker writes core dumps from the model container when the process crashes, and how it encrypts them.
+     */
+    interface EndpointConfigCoreDumpConfigArgs {
+        /**
+         * The Amazon S3 bucket to send the core dump to.
+         */
+        destinationS3Uri: pulumi.Input<string>;
+        /**
+         * The AWS Key Management Service (AWS KMS) key that SageMaker uses to encrypt the core dump data at rest using Amazon S3 server-side encryption. If you use a KMS key ID or an alias of your KMS key, the SageMaker execution role must include permissions to call kms:Encrypt.
+         */
+        kmsKeyId?: pulumi.Input<string | undefined>;
+    }
+    /**
+     * Specifies how to capture endpoint data for model monitor. The data capture configuration applies to all production variants hosted at the endpoint.
+     */
+    interface EndpointConfigDataCaptureConfigArgs {
+        /**
+         * A list of the JSON and CSV content type that the endpoint captures.
+         */
+        captureContentTypeHeader?: pulumi.Input<inputs.sagemaker.EndpointConfigCaptureContentTypeHeaderArgs | undefined>;
+        /**
+         * Specifies whether the endpoint captures input data to your model, output data from your model, or both.
+         */
+        captureOptions: pulumi.Input<pulumi.Input<inputs.sagemaker.EndpointConfigCaptureOptionArgs>[]>;
+        /**
+         * The S3 bucket where model monitor stores captured data.
+         */
+        destinationS3Uri: pulumi.Input<string>;
+        /**
+         * Set to True to enable data capture.
+         */
+        enableCapture?: pulumi.Input<boolean | undefined>;
+        /**
+         * The percentage of data to capture.
+         */
+        initialSamplingPercentage: pulumi.Input<number>;
+        /**
+         * The AWS Key Management Service (AWS KMS) key that Amazon SageMaker uses to encrypt the captured data at rest using Amazon S3 server-side encryption.
+         */
+        kmsKeyId?: pulumi.Input<string | undefined>;
+    }
+    /**
+     * A parameter to activate explainers.
+     */
+    interface EndpointConfigExplainerConfigArgs {
+        /**
+         * A member of ExplainerConfig that contains configuration parameters for the SageMaker Clarify explainer.
+         */
+        clarifyExplainerConfig?: pulumi.Input<inputs.sagemaker.EndpointConfigClarifyExplainerConfigArgs | undefined>;
+    }
+    /**
+     * Specifies an instance type and its priority for a heterogeneous endpoint. Use instance pools to configure a production variant with multiple instance types, enabling the endpoint to provision instances across different types based on priority.
+     */
+    interface EndpointConfigInstancePoolArgs {
+        /**
+         * The ML compute instance type for the instance pool.
+         */
+        instanceType: pulumi.Input<string>;
+        /**
+         * The name of a SageMaker model to use for this instance pool instead of the model specified for the production variant. Use this to deploy a different model optimized for the instance type in this pool.
+         */
+        modelNameOverride?: pulumi.Input<string | undefined>;
+        /**
+         * The priority for the instance pool. SageMaker attempts to provision instances in order of priority, starting with the lowest value. If instances for a higher-priority pool are unavailable, SageMaker attempts to provision from the next pool. Valid values: 1 to 5, where 1 is the highest priority.
+         */
+        priority: pulumi.Input<number>;
+    }
+    /**
+     * Settings that control the range in the number of instances that the endpoint provisions as it scales up or down to accommodate traffic.
+     */
+    interface EndpointConfigManagedInstanceScalingArgs {
+        /**
+         * The maximum number of instances that the endpoint can provision when it scales up to accommodate an increase in traffic.
+         */
+        maxInstanceCount?: pulumi.Input<number | undefined>;
+        /**
+         * The minimum number of instances that the endpoint must retain when it scales down to accommodate a decrease in traffic.
+         */
+        minInstanceCount?: pulumi.Input<number | undefined>;
+        /**
+         * Configures the scale-in behavior for managed instance scaling.
+         */
+        scaleInPolicy?: pulumi.Input<inputs.sagemaker.EndpointConfigScaleInPolicyArgs | undefined>;
+        /**
+         * Indicates whether managed instance scaling is enabled.
+         */
+        status?: pulumi.Input<string | undefined>;
+    }
+    /**
+     * Specifies the metrics that the endpoint publishes to Amazon CloudWatch, the frequency of publication, and whether to enable enhanced or detailed observability metrics.
+     */
+    interface EndpointConfigMetricsConfigArgs {
+        /**
+         * Specifies whether to enable detailed observability for the endpoint. When set to true, the endpoint publishes container-level inference metrics, per-GPU metrics, per-instance host metrics, and inference component placement metrics.
+         */
+        enableDetailedObservability?: pulumi.Input<boolean | undefined>;
+        /**
+         * Specifies whether to enable enhanced metrics for the endpoint. Enhanced metrics provide utilization and invocation data at instance and container granularity.
+         */
+        enableEnhancedMetrics?: pulumi.Input<boolean | undefined>;
+        /**
+         * The interval, in seconds, at which the endpoint publishes metrics to Amazon CloudWatch. Valid values are 10, 30, 60, 120, 180, 240, and 300. The default is 60.
+         */
+        metricPublishFrequencyInSeconds?: pulumi.Input<number | undefined>;
+    }
+    /**
+     * The configuration for prefix-aware routing on a SageMaker real-time inference endpoint. Specify PrefixLength and ConcurrencyThreshold to control routing behavior.
+     */
+    interface EndpointConfigPrefixAwareRoutingConfigArgs {
+        /**
+         * The maximum number of in-flight requests on the target instance before the endpoint routes to another instance. Required when RoutingStrategy is PREFIX_AWARE. Valid values are 1 to 1024.
+         */
+        concurrencyThreshold?: pulumi.Input<number | undefined>;
+        /**
+         * The maximum length of the prefix used for routing decisions. Required when RoutingStrategy is PREFIX_AWARE. Valid values are 1024 to 65536.
+         */
+        prefixLength?: pulumi.Input<number | undefined>;
+    }
+    /**
+     * Specifies a model that you want to host and the resources to deploy for hosting it.
+     */
+    interface EndpointConfigProductionVariantArgs {
+        /**
+         * Settings for the capacity reservation for the compute instances that SageMaker AI reserves for an endpoint.
+         */
+        capacityReservationConfig?: pulumi.Input<inputs.sagemaker.EndpointConfigCapacityReservationConfigArgs | undefined>;
+        /**
+         * The timeout value, in seconds, for your inference container to pass health check by SageMaker Hosting.
+         */
+        containerStartupHealthCheckTimeoutInSeconds?: pulumi.Input<number | undefined>;
+        /**
+         * Specifies configuration for a core dump from the model container when the process crashes.
+         */
+        coreDumpConfig?: pulumi.Input<inputs.sagemaker.EndpointConfigCoreDumpConfigArgs | undefined>;
+        /**
+         * You can use this parameter to turn on native AWS Systems Manager (SSM) access for a production variant behind an endpoint. By default, SSM access is disabled for all production variants behind an endpoint.
+         */
+        enableSsmAccess?: pulumi.Input<boolean | undefined>;
+        /**
+         * Specifies an option from a collection of preconfigured Amazon Machine Image (AMI) images. Each image is configured by AWS with a set of software and driver versions. AWS optimizes these configurations for different machine learning workloads. By selecting an AMI version, you can ensure that your inference environment is compatible with specific software requirements, such as CUDA driver versions, Linux kernel versions, or AWS Neuron driver versions
+         */
+        inferenceAmiVersion?: pulumi.Input<string | undefined>;
+        /**
+         * Number of instances to launch initially.
+         */
+        initialInstanceCount?: pulumi.Input<number | undefined>;
+        /**
+         * Determines initial traffic distribution among all of the models that you specify in the endpoint configuration.
+         */
+        initialVariantWeight?: pulumi.Input<number | undefined>;
+        /**
+         * A list of instance pools for the production variant. Each instance pool specifies an instance type and its priority for provisioning. Use instance pools to configure heterogeneous endpoints that deploy models across multiple instance types.
+         */
+        instancePools?: pulumi.Input<pulumi.Input<inputs.sagemaker.EndpointConfigInstancePoolArgs>[] | undefined>;
+        /**
+         * The ML compute instance type.
+         */
+        instanceType?: pulumi.Input<string | undefined>;
+        managedInstanceScaling?: pulumi.Input<inputs.sagemaker.EndpointConfigManagedInstanceScalingArgs | undefined>;
+        /**
+         * The timeout value, in seconds, to download and extract the model that you want to host from Amazon S3 to the individual inference instance associated with this production variant.
+         */
+        modelDataDownloadTimeoutInSeconds?: pulumi.Input<number | undefined>;
+        /**
+         * The name of the model that you want to host. This is the name that you specified when creating the model.
+         */
+        modelName?: pulumi.Input<string | undefined>;
+        /**
+         * Settings that control how the endpoint routes incoming traffic to the instances that the endpoint hosts.
+         */
+        routingConfig?: pulumi.Input<inputs.sagemaker.EndpointConfigRoutingConfigArgs | undefined>;
+        /**
+         * The serverless configuration for an endpoint. Specifies a serverless endpoint configuration instead of an instance-based endpoint configuration.
+         */
+        serverlessConfig?: pulumi.Input<inputs.sagemaker.EndpointConfigServerlessConfigArgs | undefined>;
+        /**
+         * The timeout value, in seconds, for provisioning instances for the production variant. When SageMaker encounters an insufficient capacity error while provisioning instances, it retries with the next instance pool (if configured) or waits until the timeout expires. This timeout applies only to capacity provisioning and does not include the time for model download or container startup.
+         */
+        variantInstanceProvisionTimeoutInSeconds?: pulumi.Input<number | undefined>;
+        /**
+         * The name of the production variant.
+         */
+        variantName: pulumi.Input<string>;
+        /**
+         * The size, in GB, of the ML storage volume attached to individual inference instance associated with the production variant. Currently only Amazon EBS gp2 storage volumes are supported.
+         */
+        volumeSizeInGb?: pulumi.Input<number | undefined>;
+    }
+    /**
+     * Settings that control how the endpoint routes incoming traffic to the instances that the endpoint hosts.
+     */
+    interface EndpointConfigRoutingConfigArgs {
+        /**
+         * The configuration for prefix-aware routing. Specify this property only when you set RoutingStrategy to PREFIX_AWARE.
+         */
+        prefixAwareRoutingConfig?: pulumi.Input<inputs.sagemaker.EndpointConfigPrefixAwareRoutingConfigArgs | undefined>;
+        /**
+         * Sets how the endpoint routes incoming traffic.
+         */
+        routingStrategy?: pulumi.Input<string | undefined>;
+    }
+    /**
+     * Specifies how the endpoint releases instances when managed instance scaling scales in.
+     */
+    interface EndpointConfigScaleInPolicyArgs {
+        /**
+         * The cooldown period, in minutes, after the last endpoint operation before the endpoint evaluates consolidation scale-in opportunities. Valid values are 5 to 1440. The default is 20.
+         */
+        cooldownInMinutes?: pulumi.Input<number | undefined>;
+        /**
+         * The maximum number of instances that the endpoint can terminate at a time during a consolidation scale-in operation. Valid values are 1 to 100. The default is 1.
+         */
+        maximumStepSize?: pulumi.Input<number | undefined>;
+        /**
+         * The strategy for scaling in instances. IDLE_RELEASE releases instances that have no hosted inference component copies. CONSOLIDATION consolidates inference component copies onto fewer instances to release more instances.
+         */
+        strategy: pulumi.Input<string>;
+    }
+    /**
+     * Specifies the serverless configuration for an endpoint variant.
+     */
+    interface EndpointConfigServerlessConfigArgs {
+        /**
+         * The maximum number of concurrent invocations your serverless endpoint can process.
+         */
+        maxConcurrency: pulumi.Input<number>;
+        /**
+         * The memory size of your serverless endpoint. Valid values are in 1 GB increments: 1024 MB, 2048 MB, 3072 MB, 4096 MB, 5120 MB, or 6144 MB.
+         */
+        memorySizeInMb: pulumi.Input<number>;
+        /**
+         * The amount of provisioned concurrency to allocate for the serverless endpoint. Should be less than or equal to MaxConcurrency.
+         */
+        provisionedConcurrency?: pulumi.Input<number | undefined>;
+    }
+    /**
+     * Specifies an Amazon Virtual Private Cloud (VPC) that your SageMaker jobs, hosted models, and compute resources have access to. You can control access to and from your resources by configuring a VPC.
+     */
+    interface EndpointConfigVpcConfigArgs {
+        /**
+         * The VPC security group IDs, in the form sg-xxxxxxxx. Specify the security groups for the VPC that is specified in the Subnets field.
+         */
+        securityGroupIds: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * The ID of the subnets in the VPC to which you want to connect your training job or model.
+         */
+        subnets: pulumi.Input<pulumi.Input<string>[]>;
+    }
     interface EndpointDeploymentConfigArgs {
         /**
          * Configuration for automatic rollback if an error occurs during deployment.
@@ -111875,6 +113315,15 @@ export declare namespace sagemaker {
          */
         subnets: pulumi.Input<pulumi.Input<string>[]>;
     }
+    /**
+     * Information on the IMDS configuration of the notebook instance
+     */
+    interface NotebookInstanceInstanceMetadataServiceConfigurationArgs {
+        /**
+         * Indicates the minimum IMDS version that the notebook instance supports. When passed as part of CreateNotebookInstance, if no value is selected, then it defaults to IMDSv1. This means that both IMDSv1 and IMDSv2 are supported. If passed as part of UpdateNotebookInstance, there is no default.
+         */
+        minimumInstanceMetadataServiceVersion: pulumi.Input<string>;
+    }
     /**
      * The configuration of an `OfflineStore` .
      */