# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities

__all__ = [
    'AppImageConfigKernelGatewayImageConfigArgs',
    'AppImageConfigKernelGatewayImageConfigFileSystemConfigArgs',
    'AppImageConfigKernelGatewayImageConfigKernelSpecArgs',
    'AppResourceSpecArgs',
    'CodeRepositoryGitConfigArgs',
    'DeviceFleetOutputConfigArgs',
    'DomainDefaultUserSettingsArgs',
    'DomainDefaultUserSettingsJupyterServerAppSettingsArgs',
    'DomainDefaultUserSettingsJupyterServerAppSettingsDefaultResourceSpecArgs',
    'DomainDefaultUserSettingsKernelGatewayAppSettingsArgs',
    'DomainDefaultUserSettingsKernelGatewayAppSettingsCustomImageArgs',
    'DomainDefaultUserSettingsKernelGatewayAppSettingsDefaultResourceSpecArgs',
    'DomainDefaultUserSettingsSharingSettingsArgs',
    'DomainDefaultUserSettingsTensorBoardAppSettingsArgs',
    'DomainDefaultUserSettingsTensorBoardAppSettingsDefaultResourceSpecArgs',
    'DomainRetentionPolicyArgs',
    'EndpointConfigurationAsyncInferenceConfigArgs',
    'EndpointConfigurationAsyncInferenceConfigClientConfigArgs',
    'EndpointConfigurationAsyncInferenceConfigOutputConfigArgs',
    'EndpointConfigurationAsyncInferenceConfigOutputConfigNotificationConfigArgs',
    'EndpointConfigurationDataCaptureConfigArgs',
    'EndpointConfigurationDataCaptureConfigCaptureContentTypeHeaderArgs',
    'EndpointConfigurationDataCaptureConfigCaptureOptionArgs',
    'EndpointConfigurationProductionVariantArgs',
    'EndpointDeploymentConfigArgs',
    'EndpointDeploymentConfigAutoRollbackConfigurationArgs',
    'EndpointDeploymentConfigAutoRollbackConfigurationAlarmArgs',
    'EndpointDeploymentConfigBlueGreenUpdatePolicyArgs',
    'EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfigurationArgs',
    'EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfigurationCanarySizeArgs',
    'EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfigurationLinearStepSizeArgs',
    'FeatureGroupFeatureDefinitionArgs',
    'FeatureGroupOfflineStoreConfigArgs',
    'FeatureGroupOfflineStoreConfigDataCatalogConfigArgs',
    'FeatureGroupOfflineStoreConfigS3StorageConfigArgs',
    'FeatureGroupOnlineStoreConfigArgs',
    'FeatureGroupOnlineStoreConfigSecurityConfigArgs',
    'FlowDefinitionHumanLoopActivationConfigArgs',
    'FlowDefinitionHumanLoopActivationConfigHumanLoopActivationConditionsConfigArgs',
    'FlowDefinitionHumanLoopConfigArgs',
    'FlowDefinitionHumanLoopConfigPublicWorkforceTaskPriceArgs',
    'FlowDefinitionHumanLoopConfigPublicWorkforceTaskPriceAmountInUsdArgs',
    'FlowDefinitionHumanLoopRequestSourceArgs',
    'FlowDefinitionOutputConfigArgs',
    'HumanTaskUIUiTemplateArgs',
    'ModelContainerArgs',
    'ModelContainerImageConfigArgs',
    'ModelInferenceExecutionConfigArgs',
    'ModelPrimaryContainerArgs',
    'ModelPrimaryContainerImageConfigArgs',
    'ModelVpcConfigArgs',
    'UserProfileUserSettingsArgs',
    'UserProfileUserSettingsJupyterServerAppSettingsArgs',
    'UserProfileUserSettingsJupyterServerAppSettingsDefaultResourceSpecArgs',
    'UserProfileUserSettingsKernelGatewayAppSettingsArgs',
    'UserProfileUserSettingsKernelGatewayAppSettingsCustomImageArgs',
    'UserProfileUserSettingsKernelGatewayAppSettingsDefaultResourceSpecArgs',
    'UserProfileUserSettingsSharingSettingsArgs',
    'UserProfileUserSettingsTensorBoardAppSettingsArgs',
    'UserProfileUserSettingsTensorBoardAppSettingsDefaultResourceSpecArgs',
    'WorkforceCognitoConfigArgs',
    'WorkforceOidcConfigArgs',
    'WorkforceSourceIpConfigArgs',
    'WorkteamMemberDefinitionArgs',
    'WorkteamMemberDefinitionCognitoMemberDefinitionArgs',
    'WorkteamMemberDefinitionOidcMemberDefinitionArgs',
    'WorkteamNotificationConfigurationArgs',
]

@pulumi.input_type
class AppImageConfigKernelGatewayImageConfigArgs:
    def __init__(__self__, *,
                 kernel_spec: pulumi.Input['AppImageConfigKernelGatewayImageConfigKernelSpecArgs'],
                 file_system_config: Optional[pulumi.Input['AppImageConfigKernelGatewayImageConfigFileSystemConfigArgs']] = None):
        """
        :param pulumi.Input['AppImageConfigKernelGatewayImageConfigKernelSpecArgs'] kernel_spec: The default branch for the Git repository. See Kernel Spec details below.
        :param pulumi.Input['AppImageConfigKernelGatewayImageConfigFileSystemConfigArgs'] file_system_config: The URL where the Git repository is located. See File System Config details below.
        """
        pulumi.set(__self__, "kernel_spec", kernel_spec)
        if file_system_config is not None:
            pulumi.set(__self__, "file_system_config", file_system_config)

    @property
    @pulumi.getter(name="kernelSpec")
    def kernel_spec(self) -> pulumi.Input['AppImageConfigKernelGatewayImageConfigKernelSpecArgs']:
        """
        The default branch for the Git repository. See Kernel Spec details below.
        """
        return pulumi.get(self, "kernel_spec")

    @kernel_spec.setter
    def kernel_spec(self, value: pulumi.Input['AppImageConfigKernelGatewayImageConfigKernelSpecArgs']):
        pulumi.set(self, "kernel_spec", value)

    @property
    @pulumi.getter(name="fileSystemConfig")
    def file_system_config(self) -> Optional[pulumi.Input['AppImageConfigKernelGatewayImageConfigFileSystemConfigArgs']]:
        """
        The URL where the Git repository is located. See File System Config details below.
        """
        return pulumi.get(self, "file_system_config")

    @file_system_config.setter
    def file_system_config(self, value: Optional[pulumi.Input['AppImageConfigKernelGatewayImageConfigFileSystemConfigArgs']]):
        pulumi.set(self, "file_system_config", value)


@pulumi.input_type
class AppImageConfigKernelGatewayImageConfigFileSystemConfigArgs:
    def __init__(__self__, *,
                 default_gid: Optional[pulumi.Input[int]] = None,
                 default_uid: Optional[pulumi.Input[int]] = None,
                 mount_path: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] default_gid: The default POSIX group ID (GID). If not specified, defaults to `100`. Valid values are `0` and `100`.
        :param pulumi.Input[int] default_uid: The default POSIX user ID (UID). If not specified, defaults to `1000`. Valid values are `0` and `1000`.
        :param pulumi.Input[str] mount_path: The path within the image to mount the user's EFS home directory. The directory should be empty. If not specified, defaults to `/home/sagemaker-user`.
        """
        if default_gid is not None:
            pulumi.set(__self__, "default_gid", default_gid)
        if default_uid is not None:
            pulumi.set(__self__, "default_uid", default_uid)
        if mount_path is not None:
            pulumi.set(__self__, "mount_path", mount_path)

    @property
    @pulumi.getter(name="defaultGid")
    def default_gid(self) -> Optional[pulumi.Input[int]]:
        """
        The default POSIX group ID (GID). If not specified, defaults to `100`. Valid values are `0` and `100`.
        """
        return pulumi.get(self, "default_gid")

    @default_gid.setter
    def default_gid(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "default_gid", value)

    @property
    @pulumi.getter(name="defaultUid")
    def default_uid(self) -> Optional[pulumi.Input[int]]:
        """
        The default POSIX user ID (UID). If not specified, defaults to `1000`. Valid values are `0` and `1000`.
        """
        return pulumi.get(self, "default_uid")

    @default_uid.setter
    def default_uid(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "default_uid", value)

    @property
    @pulumi.getter(name="mountPath")
    def mount_path(self) -> Optional[pulumi.Input[str]]:
        """
        The path within the image to mount the user's EFS home directory. The directory should be empty. If not specified, defaults to `/home/sagemaker-user`.
        """
        return pulumi.get(self, "mount_path")

    @mount_path.setter
    def mount_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mount_path", value)


@pulumi.input_type
class AppImageConfigKernelGatewayImageConfigKernelSpecArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 display_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The name of the kernel.
        :param pulumi.Input[str] display_name: The display name of the kernel.
        """
        pulumi.set(__self__, "name", name)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name of the kernel.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[str]]:
        """
        The display name of the kernel.
        """
        return pulumi.get(self, "display_name")

    @display_name.setter
    def display_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "display_name", value)


@pulumi.input_type
class AppResourceSpecArgs:
    def __init__(__self__, *,
                 instance_type: Optional[pulumi.Input[str]] = None,
                 sagemaker_image_arn: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] instance_type: The instance type that the image version runs on. For valid values see [Sagemaker Instance Types](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-available-instance-types.html).
        :param pulumi.Input[str] sagemaker_image_arn: The ARN of the SageMaker image that the image version belongs to.
        """
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if sagemaker_image_arn is not None:
            pulumi.set(__self__, "sagemaker_image_arn", sagemaker_image_arn)

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[pulumi.Input[str]]:
        """
        The instance type that the image version runs on. For valid values see [Sagemaker Instance Types](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-available-instance-types.html).
        """
        return pulumi.get(self, "instance_type")

    @instance_type.setter
    def instance_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "instance_type", value)

    @property
    @pulumi.getter(name="sagemakerImageArn")
    def sagemaker_image_arn(self) -> Optional[pulumi.Input[str]]:
        """
        The ARN of the SageMaker image that the image version belongs to.
        """
        return pulumi.get(self, "sagemaker_image_arn")

    @sagemaker_image_arn.setter
    def sagemaker_image_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sagemaker_image_arn", value)


@pulumi.input_type
class CodeRepositoryGitConfigArgs:
    def __init__(__self__, *,
                 repository_url: pulumi.Input[str],
                 branch: Optional[pulumi.Input[str]] = None,
                 secret_arn: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] repository_url: The URL where the Git repository is located.
        :param pulumi.Input[str] branch: The default branch for the Git repository.
        :param pulumi.Input[str] secret_arn: The Amazon Resource Name (ARN) of the AWS Secrets Manager secret that contains the credentials used to access the git repository. The secret must have a staging label of AWSCURRENT and must be in the following format: `{"username": UserName, "password": Password}`
        """
        pulumi.set(__self__, "repository_url", repository_url)
        if branch is not None:
            pulumi.set(__self__, "branch", branch)
        if secret_arn is not None:
            pulumi.set(__self__, "secret_arn", secret_arn)

    @property
    @pulumi.getter(name="repositoryUrl")
    def repository_url(self) -> pulumi.Input[str]:
        """
        The URL where the Git repository is located.
        """
        return pulumi.get(self, "repository_url")

    @repository_url.setter
    def repository_url(self, value: pulumi.Input[str]):
        pulumi.set(self, "repository_url", value)

    @property
    @pulumi.getter
    def branch(self) -> Optional[pulumi.Input[str]]:
        """
        The default branch for the Git repository.
        """
        return pulumi.get(self, "branch")

    @branch.setter
    def branch(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "branch", value)

    @property
    @pulumi.getter(name="secretArn")
    def secret_arn(self) -> Optional[pulumi.Input[str]]:
        """
        The Amazon Resource Name (ARN) of the AWS Secrets Manager secret that contains the credentials used to access the git repository. The secret must have a staging label of AWSCURRENT and must be in the following format: `{"username": UserName, "password": Password}`
        """
        return pulumi.get(self, "secret_arn")

    @secret_arn.setter
    def secret_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "secret_arn", value)


@pulumi.input_type
class DeviceFleetOutputConfigArgs:
    def __init__(__self__, *,
                 s3_output_location: pulumi.Input[str],
                 kms_key_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] s3_output_location: The Amazon Simple Storage (S3) bucker URI.
        :param pulumi.Input[str] kms_key_id: The AWS Key Management Service (AWS KMS) key that Amazon SageMaker uses to encrypt data on the storage volume after compilation job. If you don't provide a KMS key ID, Amazon SageMaker uses the default KMS key for Amazon S3 for your role's account.
        """
        pulumi.set(__self__, "s3_output_location", s3_output_location)
        if kms_key_id is not None:
            pulumi.set(__self__, "kms_key_id", kms_key_id)

    @property
    @pulumi.getter(name="s3OutputLocation")
    def s3_output_location(self) -> pulumi.Input[str]:
        """
        The Amazon Simple Storage (S3) bucker URI.
        """
        return pulumi.get(self, "s3_output_location")

    @s3_output_location.setter
    def s3_output_location(self, value: pulumi.Input[str]):
        pulumi.set(self, "s3_output_location", value)

    @property
    @pulumi.getter(name="kmsKeyId")
    def kms_key_id(self) -> Optional[pulumi.Input[str]]:
        """
        The AWS Key Management Service (AWS KMS) key that Amazon SageMaker uses to encrypt data on the storage volume after compilation job. If you don't provide a KMS key ID, Amazon SageMaker uses the default KMS key for Amazon S3 for your role's account.
        """
        return pulumi.get(self, "kms_key_id")

    @kms_key_id.setter
    def kms_key_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key_id", value)


@pulumi.input_type
class DomainDefaultUserSettingsArgs:
    def __init__(__self__, *,
                 execution_role: pulumi.Input[str],
                 jupyter_server_app_settings: Optional[pulumi.Input['DomainDefaultUserSettingsJupyterServerAppSettingsArgs']] = None,
                 kernel_gateway_app_settings: Optional[pulumi.Input['DomainDefaultUserSettingsKernelGatewayAppSettingsArgs']] = None,
                 security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 sharing_settings: Optional[pulumi.Input['DomainDefaultUserSettingsSharingSettingsArgs']] = None,
                 tensor_board_app_settings: Optional[pulumi.Input['DomainDefaultUserSettingsTensorBoardAppSettingsArgs']] = None):
        """
        :param pulumi.Input[str] execution_role: The execution role ARN for the user.
        :param pulumi.Input['DomainDefaultUserSettingsJupyterServerAppSettingsArgs'] jupyter_server_app_settings: The Jupyter server's app settings. See Jupyter Server App Settings below.
        :param pulumi.Input['DomainDefaultUserSettingsKernelGatewayAppSettingsArgs'] kernel_gateway_app_settings: The kernel gateway app settings. See Kernel Gateway App Settings below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] security_groups: The security groups.
        :param pulumi.Input['DomainDefaultUserSettingsSharingSettingsArgs'] sharing_settings: The sharing settings. See Sharing Settings below.
        :param pulumi.Input['DomainDefaultUserSettingsTensorBoardAppSettingsArgs'] tensor_board_app_settings: The TensorBoard app settings. See TensorBoard App Settings below.
        """
        pulumi.set(__self__, "execution_role", execution_role)
        if jupyter_server_app_settings is not None:
            pulumi.set(__self__, "jupyter_server_app_settings", jupyter_server_app_settings)
        if kernel_gateway_app_settings is not None:
            pulumi.set(__self__, "kernel_gateway_app_settings", kernel_gateway_app_settings)
        if security_groups is not None:
            pulumi.set(__self__, "security_groups", security_groups)
        if sharing_settings is not None:
            pulumi.set(__self__, "sharing_settings", sharing_settings)
        if tensor_board_app_settings is not None:
            pulumi.set(__self__, "tensor_board_app_settings", tensor_board_app_settings)

    @property
    @pulumi.getter(name="executionRole")
    def execution_role(self) -> pulumi.Input[str]:
        """
        The execution role ARN for the user.
        """
        return pulumi.get(self, "execution_role")

    @execution_role.setter
    def execution_role(self, value: pulumi.Input[str]):
        pulumi.set(self, "execution_role", value)

    @property
    @pulumi.getter(name="jupyterServerAppSettings")
    def jupyter_server_app_settings(self) -> Optional[pulumi.Input['DomainDefaultUserSettingsJupyterServerAppSettingsArgs']]:
        """
        The Jupyter server's app settings. See Jupyter Server App Settings below.
        """
        return pulumi.get(self, "jupyter_server_app_settings")

    @jupyter_server_app_settings.setter
    def jupyter_server_app_settings(self, value: Optional[pulumi.Input['DomainDefaultUserSettingsJupyterServerAppSettingsArgs']]):
        pulumi.set(self, "jupyter_server_app_settings", value)

    @property
    @pulumi.getter(name="kernelGatewayAppSettings")
    def kernel_gateway_app_settings(self) -> Optional[pulumi.Input['DomainDefaultUserSettingsKernelGatewayAppSettingsArgs']]:
        """
        The kernel gateway app settings. See Kernel Gateway App Settings below.
        """
        return pulumi.get(self, "kernel_gateway_app_settings")

    @kernel_gateway_app_settings.setter
    def kernel_gateway_app_settings(self, value: Optional[pulumi.Input['DomainDefaultUserSettingsKernelGatewayAppSettingsArgs']]):
        pulumi.set(self, "kernel_gateway_app_settings", value)

    @property
    @pulumi.getter(name="securityGroups")
    def security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The security groups.
        """
        return pulumi.get(self, "security_groups")

    @security_groups.setter
    def security_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "security_groups", value)

    @property
    @pulumi.getter(name="sharingSettings")
    def sharing_settings(self) -> Optional[pulumi.Input['DomainDefaultUserSettingsSharingSettingsArgs']]:
        """
        The sharing settings. See Sharing Settings below.
        """
        return pulumi.get(self, "sharing_settings")

    @sharing_settings.setter
    def sharing_settings(self, value: Optional[pulumi.Input['DomainDefaultUserSettingsSharingSettingsArgs']]):
        pulumi.set(self, "sharing_settings", value)

    @property
    @pulumi.getter(name="tensorBoardAppSettings")
    def tensor_board_app_settings(self) -> Optional[pulumi.Input['DomainDefaultUserSettingsTensorBoardAppSettingsArgs']]:
        """
        The TensorBoard app settings. See TensorBoard App Settings below.
        """
        return pulumi.get(self, "tensor_board_app_settings")

    @tensor_board_app_settings.setter
    def tensor_board_app_settings(self, value: Optional[pulumi.Input['DomainDefaultUserSettingsTensorBoardAppSettingsArgs']]):
        pulumi.set(self, "tensor_board_app_settings", value)


@pulumi.input_type
class DomainDefaultUserSettingsJupyterServerAppSettingsArgs:
    def __init__(__self__, *,
                 default_resource_spec: Optional[pulumi.Input['DomainDefaultUserSettingsJupyterServerAppSettingsDefaultResourceSpecArgs']] = None,
                 lifecycle_config_arns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input['DomainDefaultUserSettingsJupyterServerAppSettingsDefaultResourceSpecArgs'] default_resource_spec: The default instance type and the Amazon Resource Name (ARN) of the SageMaker image created on the instance. see Default Resource Spec below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] lifecycle_config_arns: The Amazon Resource Name (ARN) of the Lifecycle Configurations.
        """
        if default_resource_spec is not None:
            pulumi.set(__self__, "default_resource_spec", default_resource_spec)
        if lifecycle_config_arns is not None:
            pulumi.set(__self__, "lifecycle_config_arns", lifecycle_config_arns)

    @property
    @pulumi.getter(name="defaultResourceSpec")
    def default_resource_spec(self) -> Optional[pulumi.Input['DomainDefaultUserSettingsJupyterServerAppSettingsDefaultResourceSpecArgs']]:
        """
        The default instance type and the Amazon Resource Name (ARN) of the SageMaker image created on the instance. see Default Resource Spec below.
        """
        return pulumi.get(self, "default_resource_spec")

    @default_resource_spec.setter
    def default_resource_spec(self, value: Optional[pulumi.Input['DomainDefaultUserSettingsJupyterServerAppSettingsDefaultResourceSpecArgs']]):
        pulumi.set(self, "default_resource_spec", value)

    @property
    @pulumi.getter(name="lifecycleConfigArns")
    def lifecycle_config_arns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The Amazon Resource Name (ARN) of the Lifecycle Configurations.
        """
        return pulumi.get(self, "lifecycle_config_arns")

    @lifecycle_config_arns.setter
    def lifecycle_config_arns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "lifecycle_config_arns", value)


@pulumi.input_type
class DomainDefaultUserSettingsJupyterServerAppSettingsDefaultResourceSpecArgs:
    def __init__(__self__, *,
                 instance_type: Optional[pulumi.Input[str]] = None,
                 sagemaker_image_arn: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] instance_type: The instance type that the image version runs on.. For valid values see [Sagemaker Instance Types](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-available-instance-types.html).
        :param pulumi.Input[str] sagemaker_image_arn: The ARN of the SageMaker image that the image version belongs to.
        """
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if sagemaker_image_arn is not None:
            pulumi.set(__self__, "sagemaker_image_arn", sagemaker_image_arn)

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[pulumi.Input[str]]:
        """
        The instance type that the image version runs on.. For valid values see [Sagemaker Instance Types](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-available-instance-types.html).
        """
        return pulumi.get(self, "instance_type")

    @instance_type.setter
    def instance_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "instance_type", value)

    @property
    @pulumi.getter(name="sagemakerImageArn")
    def sagemaker_image_arn(self) -> Optional[pulumi.Input[str]]:
        """
        The ARN of the SageMaker image that the image version belongs to.
        """
        return pulumi.get(self, "sagemaker_image_arn")

    @sagemaker_image_arn.setter
    def sagemaker_image_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sagemaker_image_arn", value)


@pulumi.input_type
class DomainDefaultUserSettingsKernelGatewayAppSettingsArgs:
    def __init__(__self__, *,
                 custom_images: Optional[pulumi.Input[Sequence[pulumi.Input['DomainDefaultUserSettingsKernelGatewayAppSettingsCustomImageArgs']]]] = None,
                 default_resource_spec: Optional[pulumi.Input['DomainDefaultUserSettingsKernelGatewayAppSettingsDefaultResourceSpecArgs']] = None,
                 lifecycle_config_arns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['DomainDefaultUserSettingsKernelGatewayAppSettingsCustomImageArgs']]] custom_images: A list of custom SageMaker images that are configured to run as a KernelGateway app. see Custom Image below.
        :param pulumi.Input['DomainDefaultUserSettingsKernelGatewayAppSettingsDefaultResourceSpecArgs'] default_resource_spec: The default instance type and the Amazon Resource Name (ARN) of the SageMaker image created on the instance. see Default Resource Spec below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] lifecycle_config_arns: The Amazon Resource Name (ARN) of the Lifecycle Configurations.
        """
        if custom_images is not None:
            pulumi.set(__self__, "custom_images", custom_images)
        if default_resource_spec is not None:
            pulumi.set(__self__, "default_resource_spec", default_resource_spec)
        if lifecycle_config_arns is not None:
            pulumi.set(__self__, "lifecycle_config_arns", lifecycle_config_arns)

    @property
    @pulumi.getter(name="customImages")
    def custom_images(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DomainDefaultUserSettingsKernelGatewayAppSettingsCustomImageArgs']]]]:
        """
        A list of custom SageMaker images that are configured to run as a KernelGateway app. see Custom Image below.
        """
        return pulumi.get(self, "custom_images")

    @custom_images.setter
    def custom_images(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DomainDefaultUserSettingsKernelGatewayAppSettingsCustomImageArgs']]]]):
        pulumi.set(self, "custom_images", value)

    @property
    @pulumi.getter(name="defaultResourceSpec")
    def default_resource_spec(self) -> Optional[pulumi.Input['DomainDefaultUserSettingsKernelGatewayAppSettingsDefaultResourceSpecArgs']]:
        """
        The default instance type and the Amazon Resource Name (ARN) of the SageMaker image created on the instance. see Default Resource Spec below.
        """
        return pulumi.get(self, "default_resource_spec")

    @default_resource_spec.setter
    def default_resource_spec(self, value: Optional[pulumi.Input['DomainDefaultUserSettingsKernelGatewayAppSettingsDefaultResourceSpecArgs']]):
        pulumi.set(self, "default_resource_spec", value)

    @property
    @pulumi.getter(name="lifecycleConfigArns")
    def lifecycle_config_arns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The Amazon Resource Name (ARN) of the Lifecycle Configurations.
        """
        return pulumi.get(self, "lifecycle_config_arns")

    @lifecycle_config_arns.setter
    def lifecycle_config_arns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "lifecycle_config_arns", value)


@pulumi.input_type
class DomainDefaultUserSettingsKernelGatewayAppSettingsCustomImageArgs:
    def __init__(__self__, *,
                 app_image_config_name: pulumi.Input[str],
                 image_name: pulumi.Input[str],
                 image_version_number: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] app_image_config_name: The name of the App Image Config.
        :param pulumi.Input[str] image_name: The name of the Custom Image.
        :param pulumi.Input[int] image_version_number: The version number of the Custom Image.
        """
        pulumi.set(__self__, "app_image_config_name", app_image_config_name)
        pulumi.set(__self__, "image_name", image_name)
        if image_version_number is not None:
            pulumi.set(__self__, "image_version_number", image_version_number)

    @property
    @pulumi.getter(name="appImageConfigName")
    def app_image_config_name(self) -> pulumi.Input[str]:
        """
        The name of the App Image Config.
        """
        return pulumi.get(self, "app_image_config_name")

    @app_image_config_name.setter
    def app_image_config_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "app_image_config_name", value)

    @property
    @pulumi.getter(name="imageName")
    def image_name(self) -> pulumi.Input[str]:
        """
        The name of the Custom Image.
        """
        return pulumi.get(self, "image_name")

    @image_name.setter
    def image_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "image_name", value)

    @property
    @pulumi.getter(name="imageVersionNumber")
    def image_version_number(self) -> Optional[pulumi.Input[int]]:
        """
        The version number of the Custom Image.
        """
        return pulumi.get(self, "image_version_number")

    @image_version_number.setter
    def image_version_number(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "image_version_number", value)


@pulumi.input_type
class DomainDefaultUserSettingsKernelGatewayAppSettingsDefaultResourceSpecArgs:
    def __init__(__self__, *,
                 instance_type: Optional[pulumi.Input[str]] = None,
                 sagemaker_image_arn: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] instance_type: The instance type that the image version runs on.. For valid values see [Sagemaker Instance Types](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-available-instance-types.html).
        :param pulumi.Input[str] sagemaker_image_arn: The ARN of the SageMaker image that the image version belongs to.
        """
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if sagemaker_image_arn is not None:
            pulumi.set(__self__, "sagemaker_image_arn", sagemaker_image_arn)

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[pulumi.Input[str]]:
        """
        The instance type that the image version runs on.. For valid values see [Sagemaker Instance Types](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-available-instance-types.html).
        """
        return pulumi.get(self, "instance_type")

    @instance_type.setter
    def instance_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "instance_type", value)

    @property
    @pulumi.getter(name="sagemakerImageArn")
    def sagemaker_image_arn(self) -> Optional[pulumi.Input[str]]:
        """
        The ARN of the SageMaker image that the image version belongs to.
        """
        return pulumi.get(self, "sagemaker_image_arn")

    @sagemaker_image_arn.setter
    def sagemaker_image_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sagemaker_image_arn", value)


@pulumi.input_type
class DomainDefaultUserSettingsSharingSettingsArgs:
    def __init__(__self__, *,
                 notebook_output_option: Optional[pulumi.Input[str]] = None,
                 s3_kms_key_id: Optional[pulumi.Input[str]] = None,
                 s3_output_path: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] notebook_output_option: Whether to include the notebook cell output when sharing the notebook. The default is `Disabled`. Valid values are `Allowed` and `Disabled`.
        :param pulumi.Input[str] s3_kms_key_id: When `notebook_output_option` is Allowed, the AWS Key Management Service (KMS) encryption key ID used to encrypt the notebook cell output in the Amazon S3 bucket.
        :param pulumi.Input[str] s3_output_path: When `notebook_output_option` is Allowed, the Amazon S3 bucket used to save the notebook cell output.
        """
        if notebook_output_option is not None:
            pulumi.set(__self__, "notebook_output_option", notebook_output_option)
        if s3_kms_key_id is not None:
            pulumi.set(__self__, "s3_kms_key_id", s3_kms_key_id)
        if s3_output_path is not None:
            pulumi.set(__self__, "s3_output_path", s3_output_path)

    @property
    @pulumi.getter(name="notebookOutputOption")
    def notebook_output_option(self) -> Optional[pulumi.Input[str]]:
        """
        Whether to include the notebook cell output when sharing the notebook. The default is `Disabled`. Valid values are `Allowed` and `Disabled`.
        """
        return pulumi.get(self, "notebook_output_option")

    @notebook_output_option.setter
    def notebook_output_option(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "notebook_output_option", value)

    @property
    @pulumi.getter(name="s3KmsKeyId")
    def s3_kms_key_id(self) -> Optional[pulumi.Input[str]]:
        """
        When `notebook_output_option` is Allowed, the AWS Key Management Service (KMS) encryption key ID used to encrypt the notebook cell output in the Amazon S3 bucket.
        """
        return pulumi.get(self, "s3_kms_key_id")

    @s3_kms_key_id.setter
    def s3_kms_key_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "s3_kms_key_id", value)

    @property
    @pulumi.getter(name="s3OutputPath")
    def s3_output_path(self) -> Optional[pulumi.Input[str]]:
        """
        When `notebook_output_option` is Allowed, the Amazon S3 bucket used to save the notebook cell output.
        """
        return pulumi.get(self, "s3_output_path")

    @s3_output_path.setter
    def s3_output_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "s3_output_path", value)


@pulumi.input_type
class DomainDefaultUserSettingsTensorBoardAppSettingsArgs:
    def __init__(__self__, *,
                 default_resource_spec: Optional[pulumi.Input['DomainDefaultUserSettingsTensorBoardAppSettingsDefaultResourceSpecArgs']] = None):
        """
        :param pulumi.Input['DomainDefaultUserSettingsTensorBoardAppSettingsDefaultResourceSpecArgs'] default_resource_spec: The default instance type and the Amazon Resource Name (ARN) of the SageMaker image created on the instance. see Default Resource Spec below.
        """
        if default_resource_spec is not None:
            pulumi.set(__self__, "default_resource_spec", default_resource_spec)

    @property
    @pulumi.getter(name="defaultResourceSpec")
    def default_resource_spec(self) -> Optional[pulumi.Input['DomainDefaultUserSettingsTensorBoardAppSettingsDefaultResourceSpecArgs']]:
        """
        The default instance type and the Amazon Resource Name (ARN) of the SageMaker image created on the instance. see Default Resource Spec below.
        """
        return pulumi.get(self, "default_resource_spec")

    @default_resource_spec.setter
    def default_resource_spec(self, value: Optional[pulumi.Input['DomainDefaultUserSettingsTensorBoardAppSettingsDefaultResourceSpecArgs']]):
        pulumi.set(self, "default_resource_spec", value)


@pulumi.input_type
class DomainDefaultUserSettingsTensorBoardAppSettingsDefaultResourceSpecArgs:
    def __init__(__self__, *,
                 instance_type: Optional[pulumi.Input[str]] = None,
                 sagemaker_image_arn: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] instance_type: The instance type that the image version runs on.. For valid values see [Sagemaker Instance Types](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-available-instance-types.html).
        :param pulumi.Input[str] sagemaker_image_arn: The ARN of the SageMaker image that the image version belongs to.
        """
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if sagemaker_image_arn is not None:
            pulumi.set(__self__, "sagemaker_image_arn", sagemaker_image_arn)

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[pulumi.Input[str]]:
        """
        The instance type that the image version runs on.. For valid values see [Sagemaker Instance Types](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-available-instance-types.html).
        """
        return pulumi.get(self, "instance_type")

    @instance_type.setter
    def instance_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "instance_type", value)

    @property
    @pulumi.getter(name="sagemakerImageArn")
    def sagemaker_image_arn(self) -> Optional[pulumi.Input[str]]:
        """
        The ARN of the SageMaker image that the image version belongs to.
        """
        return pulumi.get(self, "sagemaker_image_arn")

    @sagemaker_image_arn.setter
    def sagemaker_image_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sagemaker_image_arn", value)


@pulumi.input_type
class DomainRetentionPolicyArgs:
    def __init__(__self__, *,
                 home_efs_file_system: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] home_efs_file_system: The retention policy for data stored on an Amazon Elastic File System (EFS) volume. Default value is `Retain`.
        """
        if home_efs_file_system is not None:
            pulumi.set(__self__, "home_efs_file_system", home_efs_file_system)

    @property
    @pulumi.getter(name="homeEfsFileSystem")
    def home_efs_file_system(self) -> Optional[pulumi.Input[str]]:
        """
        The retention policy for data stored on an Amazon Elastic File System (EFS) volume. Default value is `Retain`.
        """
        return pulumi.get(self, "home_efs_file_system")

    @home_efs_file_system.setter
    def home_efs_file_system(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "home_efs_file_system", value)


@pulumi.input_type
class EndpointConfigurationAsyncInferenceConfigArgs:
    def __init__(__self__, *,
                 output_config: pulumi.Input['EndpointConfigurationAsyncInferenceConfigOutputConfigArgs'],
                 client_config: Optional[pulumi.Input['EndpointConfigurationAsyncInferenceConfigClientConfigArgs']] = None):
        """
        :param pulumi.Input['EndpointConfigurationAsyncInferenceConfigOutputConfigArgs'] output_config: Specifies the configuration for asynchronous inference invocation outputs.
        :param pulumi.Input['EndpointConfigurationAsyncInferenceConfigClientConfigArgs'] client_config: Configures the behavior of the client used by Amazon SageMaker to interact with the model container during asynchronous inference.
        """
        pulumi.set(__self__, "output_config", output_config)
        if client_config is not None:
            pulumi.set(__self__, "client_config", client_config)

    @property
    @pulumi.getter(name="outputConfig")
    def output_config(self) -> pulumi.Input['EndpointConfigurationAsyncInferenceConfigOutputConfigArgs']:
        """
        Specifies the configuration for asynchronous inference invocation outputs.
        """
        return pulumi.get(self, "output_config")

    @output_config.setter
    def output_config(self, value: pulumi.Input['EndpointConfigurationAsyncInferenceConfigOutputConfigArgs']):
        pulumi.set(self, "output_config", value)

    @property
    @pulumi.getter(name="clientConfig")
    def client_config(self) -> Optional[pulumi.Input['EndpointConfigurationAsyncInferenceConfigClientConfigArgs']]:
        """
        Configures the behavior of the client used by Amazon SageMaker to interact with the model container during asynchronous inference.
        """
        return pulumi.get(self, "client_config")

    @client_config.setter
    def client_config(self, value: Optional[pulumi.Input['EndpointConfigurationAsyncInferenceConfigClientConfigArgs']]):
        pulumi.set(self, "client_config", value)


@pulumi.input_type
class EndpointConfigurationAsyncInferenceConfigClientConfigArgs:
    def __init__(__self__, *,
                 max_concurrent_invocations_per_instance: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] max_concurrent_invocations_per_instance: The maximum number of concurrent requests sent by the SageMaker client to the model container. If no value is provided, Amazon SageMaker will choose an optimal value for you.
        """
        if max_concurrent_invocations_per_instance is not None:
            pulumi.set(__self__, "max_concurrent_invocations_per_instance", max_concurrent_invocations_per_instance)

    @property
    @pulumi.getter(name="maxConcurrentInvocationsPerInstance")
    def max_concurrent_invocations_per_instance(self) -> Optional[pulumi.Input[int]]:
        """
        The maximum number of concurrent requests sent by the SageMaker client to the model container. If no value is provided, Amazon SageMaker will choose an optimal value for you.
        """
        return pulumi.get(self, "max_concurrent_invocations_per_instance")

    @max_concurrent_invocations_per_instance.setter
    def max_concurrent_invocations_per_instance(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_concurrent_invocations_per_instance", value)


@pulumi.input_type
class EndpointConfigurationAsyncInferenceConfigOutputConfigArgs:
    def __init__(__self__, *,
                 s3_output_path: pulumi.Input[str],
                 kms_key_id: Optional[pulumi.Input[str]] = None,
                 notification_config: Optional[pulumi.Input['EndpointConfigurationAsyncInferenceConfigOutputConfigNotificationConfigArgs']] = None):
        """
        :param pulumi.Input[str] s3_output_path: The Amazon S3 location to upload inference responses to.
        :param pulumi.Input[str] kms_key_id: The Amazon Web Services Key Management Service (Amazon Web Services KMS) key that Amazon SageMaker uses to encrypt the asynchronous inference output in Amazon S3.
        :param pulumi.Input['EndpointConfigurationAsyncInferenceConfigOutputConfigNotificationConfigArgs'] notification_config: Specifies the configuration for notifications of inference results for asynchronous inference.
        """
        pulumi.set(__self__, "s3_output_path", s3_output_path)
        if kms_key_id is not None:
            pulumi.set(__self__, "kms_key_id", kms_key_id)
        if notification_config is not None:
            pulumi.set(__self__, "notification_config", notification_config)

    @property
    @pulumi.getter(name="s3OutputPath")
    def s3_output_path(self) -> pulumi.Input[str]:
        """
        The Amazon S3 location to upload inference responses to.
        """
        return pulumi.get(self, "s3_output_path")

    @s3_output_path.setter
    def s3_output_path(self, value: pulumi.Input[str]):
        pulumi.set(self, "s3_output_path", value)

    @property
    @pulumi.getter(name="kmsKeyId")
    def kms_key_id(self) -> Optional[pulumi.Input[str]]:
        """
        The Amazon Web Services Key Management Service (Amazon Web Services KMS) key that Amazon SageMaker uses to encrypt the asynchronous inference output in Amazon S3.
        """
        return pulumi.get(self, "kms_key_id")

    @kms_key_id.setter
    def kms_key_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key_id", value)

    @property
    @pulumi.getter(name="notificationConfig")
    def notification_config(self) -> Optional[pulumi.Input['EndpointConfigurationAsyncInferenceConfigOutputConfigNotificationConfigArgs']]:
        """
        Specifies the configuration for notifications of inference results for asynchronous inference.
        """
        return pulumi.get(self, "notification_config")

    @notification_config.setter
    def notification_config(self, value: Optional[pulumi.Input['EndpointConfigurationAsyncInferenceConfigOutputConfigNotificationConfigArgs']]):
        pulumi.set(self, "notification_config", value)


@pulumi.input_type
class EndpointConfigurationAsyncInferenceConfigOutputConfigNotificationConfigArgs:
    def __init__(__self__, *,
                 error_topic: Optional[pulumi.Input[str]] = None,
                 success_topic: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] error_topic: Amazon SNS topic to post a notification to when inference fails. If no topic is provided, no notification is sent on failure.
        :param pulumi.Input[str] success_topic: Amazon SNS topic to post a notification to when inference completes successfully. If no topic is provided, no notification is sent on success.
        """
        if error_topic is not None:
            pulumi.set(__self__, "error_topic", error_topic)
        if success_topic is not None:
            pulumi.set(__self__, "success_topic", success_topic)

    @property
    @pulumi.getter(name="errorTopic")
    def error_topic(self) -> Optional[pulumi.Input[str]]:
        """
        Amazon SNS topic to post a notification to when inference fails. If no topic is provided, no notification is sent on failure.
        """
        return pulumi.get(self, "error_topic")

    @error_topic.setter
    def error_topic(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "error_topic", value)

    @property
    @pulumi.getter(name="successTopic")
    def success_topic(self) -> Optional[pulumi.Input[str]]:
        """
        Amazon SNS topic to post a notification to when inference completes successfully. If no topic is provided, no notification is sent on success.
        """
        return pulumi.get(self, "success_topic")

    @success_topic.setter
    def success_topic(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "success_topic", value)


@pulumi.input_type
class EndpointConfigurationDataCaptureConfigArgs:
    def __init__(__self__, *,
                 capture_options: pulumi.Input[Sequence[pulumi.Input['EndpointConfigurationDataCaptureConfigCaptureOptionArgs']]],
                 destination_s3_uri: pulumi.Input[str],
                 initial_sampling_percentage: pulumi.Input[int],
                 capture_content_type_header: Optional[pulumi.Input['EndpointConfigurationDataCaptureConfigCaptureContentTypeHeaderArgs']] = None,
                 enable_capture: Optional[pulumi.Input[bool]] = None,
                 kms_key_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['EndpointConfigurationDataCaptureConfigCaptureOptionArgs']]] capture_options: Specifies what data to capture. Fields are documented below.
        :param pulumi.Input[str] destination_s3_uri: The URL for S3 location where the captured data is stored.
        :param pulumi.Input[int] initial_sampling_percentage: Portion of data to capture. Should be between 0 and 100.
        :param pulumi.Input['EndpointConfigurationDataCaptureConfigCaptureContentTypeHeaderArgs'] capture_content_type_header: The content type headers to capture. Fields are documented below.
        :param pulumi.Input[bool] enable_capture: Flag to enable data capture. Defaults to `false`.
        :param pulumi.Input[str] kms_key_id: The Amazon Web Services Key Management Service (Amazon Web Services KMS) key that Amazon SageMaker uses to encrypt the asynchronous inference output in Amazon S3.
        """
        pulumi.set(__self__, "capture_options", capture_options)
        pulumi.set(__self__, "destination_s3_uri", destination_s3_uri)
        pulumi.set(__self__, "initial_sampling_percentage", initial_sampling_percentage)
        if capture_content_type_header is not None:
            pulumi.set(__self__, "capture_content_type_header", capture_content_type_header)
        if enable_capture is not None:
            pulumi.set(__self__, "enable_capture", enable_capture)
        if kms_key_id is not None:
            pulumi.set(__self__, "kms_key_id", kms_key_id)

    @property
    @pulumi.getter(name="captureOptions")
    def capture_options(self) -> pulumi.Input[Sequence[pulumi.Input['EndpointConfigurationDataCaptureConfigCaptureOptionArgs']]]:
        """
        Specifies what data to capture. Fields are documented below.
        """
        return pulumi.get(self, "capture_options")

    @capture_options.setter
    def capture_options(self, value: pulumi.Input[Sequence[pulumi.Input['EndpointConfigurationDataCaptureConfigCaptureOptionArgs']]]):
        pulumi.set(self, "capture_options", value)

    @property
    @pulumi.getter(name="destinationS3Uri")
    def destination_s3_uri(self) -> pulumi.Input[str]:
        """
        The URL for S3 location where the captured data is stored.
        """
        return pulumi.get(self, "destination_s3_uri")

    @destination_s3_uri.setter
    def destination_s3_uri(self, value: pulumi.Input[str]):
        pulumi.set(self, "destination_s3_uri", value)

    @property
    @pulumi.getter(name="initialSamplingPercentage")
    def initial_sampling_percentage(self) -> pulumi.Input[int]:
        """
        Portion of data to capture. Should be between 0 and 100.
        """
        return pulumi.get(self, "initial_sampling_percentage")

    @initial_sampling_percentage.setter
    def initial_sampling_percentage(self, value: pulumi.Input[int]):
        pulumi.set(self, "initial_sampling_percentage", value)

    @property
    @pulumi.getter(name="captureContentTypeHeader")
    def capture_content_type_header(self) -> Optional[pulumi.Input['EndpointConfigurationDataCaptureConfigCaptureContentTypeHeaderArgs']]:
        """
        The content type headers to capture. Fields are documented below.
        """
        return pulumi.get(self, "capture_content_type_header")

    @capture_content_type_header.setter
    def capture_content_type_header(self, value: Optional[pulumi.Input['EndpointConfigurationDataCaptureConfigCaptureContentTypeHeaderArgs']]):
        pulumi.set(self, "capture_content_type_header", value)

    @property
    @pulumi.getter(name="enableCapture")
    def enable_capture(self) -> Optional[pulumi.Input[bool]]:
        """
        Flag to enable data capture. Defaults to `false`.
        """
        return pulumi.get(self, "enable_capture")

    @enable_capture.setter
    def enable_capture(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_capture", value)

    @property
    @pulumi.getter(name="kmsKeyId")
    def kms_key_id(self) -> Optional[pulumi.Input[str]]:
        """
        The Amazon Web Services Key Management Service (Amazon Web Services KMS) key that Amazon SageMaker uses to encrypt the asynchronous inference output in Amazon S3.
        """
        return pulumi.get(self, "kms_key_id")

    @kms_key_id.setter
    def kms_key_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key_id", value)


@pulumi.input_type
class EndpointConfigurationDataCaptureConfigCaptureContentTypeHeaderArgs:
    def __init__(__self__, *,
                 csv_content_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 json_content_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] csv_content_types: The CSV content type headers to capture.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] json_content_types: The JSON content type headers to capture.
        """
        if csv_content_types is not None:
            pulumi.set(__self__, "csv_content_types", csv_content_types)
        if json_content_types is not None:
            pulumi.set(__self__, "json_content_types", json_content_types)

    @property
    @pulumi.getter(name="csvContentTypes")
    def csv_content_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The CSV content type headers to capture.
        """
        return pulumi.get(self, "csv_content_types")

    @csv_content_types.setter
    def csv_content_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "csv_content_types", value)

    @property
    @pulumi.getter(name="jsonContentTypes")
    def json_content_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The JSON content type headers to capture.
        """
        return pulumi.get(self, "json_content_types")

    @json_content_types.setter
    def json_content_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "json_content_types", value)


@pulumi.input_type
class EndpointConfigurationDataCaptureConfigCaptureOptionArgs:
    def __init__(__self__, *,
                 capture_mode: pulumi.Input[str]):
        """
        :param pulumi.Input[str] capture_mode: Specifies the data to be captured. Should be one of `Input` or `Output`.
        """
        pulumi.set(__self__, "capture_mode", capture_mode)

    @property
    @pulumi.getter(name="captureMode")
    def capture_mode(self) -> pulumi.Input[str]:
        """
        Specifies the data to be captured. Should be one of `Input` or `Output`.
        """
        return pulumi.get(self, "capture_mode")

    @capture_mode.setter
    def capture_mode(self, value: pulumi.Input[str]):
        pulumi.set(self, "capture_mode", value)


@pulumi.input_type
class EndpointConfigurationProductionVariantArgs:
    def __init__(__self__, *,
                 initial_instance_count: pulumi.Input[int],
                 instance_type: pulumi.Input[str],
                 model_name: pulumi.Input[str],
                 accelerator_type: Optional[pulumi.Input[str]] = None,
                 initial_variant_weight: Optional[pulumi.Input[float]] = None,
                 variant_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] initial_instance_count: Initial number of instances used for auto-scaling.
        :param pulumi.Input[str] instance_type: The type of instance to start.
        :param pulumi.Input[str] model_name: The name of the model to use.
        :param pulumi.Input[str] accelerator_type: The size of the Elastic Inference (EI) instance to use for the production variant.
        :param pulumi.Input[float] initial_variant_weight: Determines initial traffic distribution among all of the models that you specify in the endpoint configuration. If unspecified, it defaults to 1.0.
        :param pulumi.Input[str] variant_name: The name of the variant. If omitted, this provider will assign a random, unique name.
        """
        pulumi.set(__self__, "initial_instance_count", initial_instance_count)
        pulumi.set(__self__, "instance_type", instance_type)
        pulumi.set(__self__, "model_name", model_name)
        if accelerator_type is not None:
            pulumi.set(__self__, "accelerator_type", accelerator_type)
        if initial_variant_weight is not None:
            pulumi.set(__self__, "initial_variant_weight", initial_variant_weight)
        if variant_name is not None:
            pulumi.set(__self__, "variant_name", variant_name)

    @property
    @pulumi.getter(name="initialInstanceCount")
    def initial_instance_count(self) -> pulumi.Input[int]:
        """
        Initial number of instances used for auto-scaling.
        """
        return pulumi.get(self, "initial_instance_count")

    @initial_instance_count.setter
    def initial_instance_count(self, value: pulumi.Input[int]):
        pulumi.set(self, "initial_instance_count", value)

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> pulumi.Input[str]:
        """
        The type of instance to start.
        """
        return pulumi.get(self, "instance_type")

    @instance_type.setter
    def instance_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "instance_type", value)

    @property
    @pulumi.getter(name="modelName")
    def model_name(self) -> pulumi.Input[str]:
        """
        The name of the model to use.
        """
        return pulumi.get(self, "model_name")

    @model_name.setter
    def model_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "model_name", value)

    @property
    @pulumi.getter(name="acceleratorType")
    def accelerator_type(self) -> Optional[pulumi.Input[str]]:
        """
        The size of the Elastic Inference (EI) instance to use for the production variant.
        """
        return pulumi.get(self, "accelerator_type")

    @accelerator_type.setter
    def accelerator_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "accelerator_type", value)

    @property
    @pulumi.getter(name="initialVariantWeight")
    def initial_variant_weight(self) -> Optional[pulumi.Input[float]]:
        """
        Determines initial traffic distribution among all of the models that you specify in the endpoint configuration. If unspecified, it defaults to 1.0.
        """
        return pulumi.get(self, "initial_variant_weight")

    @initial_variant_weight.setter
    def initial_variant_weight(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "initial_variant_weight", value)

    @property
    @pulumi.getter(name="variantName")
    def variant_name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the variant. If omitted, this provider will assign a random, unique name.
        """
        return pulumi.get(self, "variant_name")

    @variant_name.setter
    def variant_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "variant_name", value)


@pulumi.input_type
class EndpointDeploymentConfigArgs:
    def __init__(__self__, *,
                 blue_green_update_policy: pulumi.Input['EndpointDeploymentConfigBlueGreenUpdatePolicyArgs'],
                 auto_rollback_configuration: Optional[pulumi.Input['EndpointDeploymentConfigAutoRollbackConfigurationArgs']] = None):
        """
        :param pulumi.Input['EndpointDeploymentConfigBlueGreenUpdatePolicyArgs'] blue_green_update_policy: Update policy for a blue/green deployment. If this update policy is specified, SageMaker creates a new fleet during the deployment while maintaining the old fleet. See Blue Green Update Config.
        :param pulumi.Input['EndpointDeploymentConfigAutoRollbackConfigurationArgs'] auto_rollback_configuration: Automatic rollback configuration for handling endpoint deployment failures and recovery. See Auto Rollback Configuration.
        """
        pulumi.set(__self__, "blue_green_update_policy", blue_green_update_policy)
        if auto_rollback_configuration is not None:
            pulumi.set(__self__, "auto_rollback_configuration", auto_rollback_configuration)

    @property
    @pulumi.getter(name="blueGreenUpdatePolicy")
    def blue_green_update_policy(self) -> pulumi.Input['EndpointDeploymentConfigBlueGreenUpdatePolicyArgs']:
        """
        Update policy for a blue/green deployment. If this update policy is specified, SageMaker creates a new fleet during the deployment while maintaining the old fleet. See Blue Green Update Config.
        """
        return pulumi.get(self, "blue_green_update_policy")

    @blue_green_update_policy.setter
    def blue_green_update_policy(self, value: pulumi.Input['EndpointDeploymentConfigBlueGreenUpdatePolicyArgs']):
        pulumi.set(self, "blue_green_update_policy", value)

    @property
    @pulumi.getter(name="autoRollbackConfiguration")
    def auto_rollback_configuration(self) -> Optional[pulumi.Input['EndpointDeploymentConfigAutoRollbackConfigurationArgs']]:
        """
        Automatic rollback configuration for handling endpoint deployment failures and recovery. See Auto Rollback Configuration.
        """
        return pulumi.get(self, "auto_rollback_configuration")

    @auto_rollback_configuration.setter
    def auto_rollback_configuration(self, value: Optional[pulumi.Input['EndpointDeploymentConfigAutoRollbackConfigurationArgs']]):
        pulumi.set(self, "auto_rollback_configuration", value)


@pulumi.input_type
class EndpointDeploymentConfigAutoRollbackConfigurationArgs:
    def __init__(__self__, *,
                 alarms: Optional[pulumi.Input[Sequence[pulumi.Input['EndpointDeploymentConfigAutoRollbackConfigurationAlarmArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['EndpointDeploymentConfigAutoRollbackConfigurationAlarmArgs']]] alarms: List of CloudWatch alarms in your account that are configured to monitor metrics on an endpoint. If any alarms are tripped during a deployment, SageMaker rolls back the deployment. See Alarms.
        """
        if alarms is not None:
            pulumi.set(__self__, "alarms", alarms)

    @property
    @pulumi.getter
    def alarms(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['EndpointDeploymentConfigAutoRollbackConfigurationAlarmArgs']]]]:
        """
        List of CloudWatch alarms in your account that are configured to monitor metrics on an endpoint. If any alarms are tripped during a deployment, SageMaker rolls back the deployment. See Alarms.
        """
        return pulumi.get(self, "alarms")

    @alarms.setter
    def alarms(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['EndpointDeploymentConfigAutoRollbackConfigurationAlarmArgs']]]]):
        pulumi.set(self, "alarms", value)


@pulumi.input_type
class EndpointDeploymentConfigAutoRollbackConfigurationAlarmArgs:
    def __init__(__self__, *,
                 alarm_name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] alarm_name: The name of a CloudWatch alarm in your account.
        """
        pulumi.set(__self__, "alarm_name", alarm_name)

    @property
    @pulumi.getter(name="alarmName")
    def alarm_name(self) -> pulumi.Input[str]:
        """
        The name of a CloudWatch alarm in your account.
        """
        return pulumi.get(self, "alarm_name")

    @alarm_name.setter
    def alarm_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "alarm_name", value)


@pulumi.input_type
class EndpointDeploymentConfigBlueGreenUpdatePolicyArgs:
    def __init__(__self__, *,
                 traffic_routing_configuration: pulumi.Input['EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfigurationArgs'],
                 maximum_execution_timeout_in_seconds: Optional[pulumi.Input[int]] = None,
                 termination_wait_in_seconds: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input['EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfigurationArgs'] traffic_routing_configuration: Defines the traffic routing strategy to shift traffic from the old fleet to the new fleet during an endpoint deployment. See Traffic Routing Configuration.
        :param pulumi.Input[int] maximum_execution_timeout_in_seconds: Maximum execution timeout for the deployment. Note that the timeout value should be larger than the total waiting time specified in `termination_wait_in_seconds` and `wait_interval_in_seconds`. Valid values are between `600` and `14400`.
        :param pulumi.Input[int] termination_wait_in_seconds: Additional waiting time in seconds after the completion of an endpoint deployment before terminating the old endpoint fleet. Default is `0`. Valid values are between `0` and `3600`.
        """
        pulumi.set(__self__, "traffic_routing_configuration", traffic_routing_configuration)
        if maximum_execution_timeout_in_seconds is not None:
            pulumi.set(__self__, "maximum_execution_timeout_in_seconds", maximum_execution_timeout_in_seconds)
        if termination_wait_in_seconds is not None:
            pulumi.set(__self__, "termination_wait_in_seconds", termination_wait_in_seconds)

    @property
    @pulumi.getter(name="trafficRoutingConfiguration")
    def traffic_routing_configuration(self) -> pulumi.Input['EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfigurationArgs']:
        """
        Defines the traffic routing strategy to shift traffic from the old fleet to the new fleet during an endpoint deployment. See Traffic Routing Configuration.
        """
        return pulumi.get(self, "traffic_routing_configuration")

    @traffic_routing_configuration.setter
    def traffic_routing_configuration(self, value: pulumi.Input['EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfigurationArgs']):
        pulumi.set(self, "traffic_routing_configuration", value)

    @property
    @pulumi.getter(name="maximumExecutionTimeoutInSeconds")
    def maximum_execution_timeout_in_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        Maximum execution timeout for the deployment. Note that the timeout value should be larger than the total waiting time specified in `termination_wait_in_seconds` and `wait_interval_in_seconds`. Valid values are between `600` and `14400`.
        """
        return pulumi.get(self, "maximum_execution_timeout_in_seconds")

    @maximum_execution_timeout_in_seconds.setter
    def maximum_execution_timeout_in_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "maximum_execution_timeout_in_seconds", value)

    @property
    @pulumi.getter(name="terminationWaitInSeconds")
    def termination_wait_in_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        Additional waiting time in seconds after the completion of an endpoint deployment before terminating the old endpoint fleet. Default is `0`. Valid values are between `0` and `3600`.
        """
        return pulumi.get(self, "termination_wait_in_seconds")

    @termination_wait_in_seconds.setter
    def termination_wait_in_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "termination_wait_in_seconds", value)


@pulumi.input_type
class EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfigurationArgs:
    def __init__(__self__, *,
                 type: pulumi.Input[str],
                 wait_interval_in_seconds: pulumi.Input[int],
                 canary_size: Optional[pulumi.Input['EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfigurationCanarySizeArgs']] = None,
                 linear_step_size: Optional[pulumi.Input['EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfigurationLinearStepSizeArgs']] = None):
        """
        :param pulumi.Input[str] type: Specifies the endpoint capacity type. Valid values are: `INSTANCE_COUNT`, or `CAPACITY_PERCENT`.
        :param pulumi.Input[int] wait_interval_in_seconds: The waiting time (in seconds) between incremental steps to turn on traffic on the new endpoint fleet. Valid values are between `0` and `3600`.
        :param pulumi.Input['EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfigurationCanarySizeArgs'] canary_size: Batch size for the first step to turn on traffic on the new endpoint fleet. Value must be less than or equal to 50% of the variant's total instance count. See Canary Size.
        :param pulumi.Input['EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfigurationLinearStepSizeArgs'] linear_step_size: Batch size for each step to turn on traffic on the new endpoint fleet. Value must be 10-50% of the variant's total instance count. See Linear Step Size.
        """
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "wait_interval_in_seconds", wait_interval_in_seconds)
        if canary_size is not None:
            pulumi.set(__self__, "canary_size", canary_size)
        if linear_step_size is not None:
            pulumi.set(__self__, "linear_step_size", linear_step_size)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        Specifies the endpoint capacity type. Valid values are: `INSTANCE_COUNT`, or `CAPACITY_PERCENT`.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)

    @property
    @pulumi.getter(name="waitIntervalInSeconds")
    def wait_interval_in_seconds(self) -> pulumi.Input[int]:
        """
        The waiting time (in seconds) between incremental steps to turn on traffic on the new endpoint fleet. Valid values are between `0` and `3600`.
        """
        return pulumi.get(self, "wait_interval_in_seconds")

    @wait_interval_in_seconds.setter
    def wait_interval_in_seconds(self, value: pulumi.Input[int]):
        pulumi.set(self, "wait_interval_in_seconds", value)

    @property
    @pulumi.getter(name="canarySize")
    def canary_size(self) -> Optional[pulumi.Input['EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfigurationCanarySizeArgs']]:
        """
        Batch size for the first step to turn on traffic on the new endpoint fleet. Value must be less than or equal to 50% of the variant's total instance count. See Canary Size.
        """
        return pulumi.get(self, "canary_size")

    @canary_size.setter
    def canary_size(self, value: Optional[pulumi.Input['EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfigurationCanarySizeArgs']]):
        pulumi.set(self, "canary_size", value)

    @property
    @pulumi.getter(name="linearStepSize")
    def linear_step_size(self) -> Optional[pulumi.Input['EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfigurationLinearStepSizeArgs']]:
        """
        Batch size for each step to turn on traffic on the new endpoint fleet. Value must be 10-50% of the variant's total instance count. See Linear Step Size.
        """
        return pulumi.get(self, "linear_step_size")

    @linear_step_size.setter
    def linear_step_size(self, value: Optional[pulumi.Input['EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfigurationLinearStepSizeArgs']]):
        pulumi.set(self, "linear_step_size", value)


@pulumi.input_type
class EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfigurationCanarySizeArgs:
    def __init__(__self__, *,
                 type: pulumi.Input[str],
                 value: pulumi.Input[int]):
        """
        :param pulumi.Input[str] type: Specifies the endpoint capacity type. Valid values are: `INSTANCE_COUNT`, or `CAPACITY_PERCENT`.
        :param pulumi.Input[int] value: Defines the capacity size, either as a number of instances or a capacity percentage.
        """
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        Specifies the endpoint capacity type. Valid values are: `INSTANCE_COUNT`, or `CAPACITY_PERCENT`.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[int]:
        """
        Defines the capacity size, either as a number of instances or a capacity percentage.
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[int]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfigurationLinearStepSizeArgs:
    def __init__(__self__, *,
                 type: pulumi.Input[str],
                 value: pulumi.Input[int]):
        """
        :param pulumi.Input[str] type: Specifies the endpoint capacity type. Valid values are: `INSTANCE_COUNT`, or `CAPACITY_PERCENT`.
        :param pulumi.Input[int] value: Defines the capacity size, either as a number of instances or a capacity percentage.
        """
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        Specifies the endpoint capacity type. Valid values are: `INSTANCE_COUNT`, or `CAPACITY_PERCENT`.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[int]:
        """
        Defines the capacity size, either as a number of instances or a capacity percentage.
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[int]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class FeatureGroupFeatureDefinitionArgs:
    def __init__(__self__, *,
                 feature_name: Optional[pulumi.Input[str]] = None,
                 feature_type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] feature_name: The name of a feature. `feature_name` cannot be any of the following: `is_deleted`, `write_time`, `api_invocation_time`.
        :param pulumi.Input[str] feature_type: The value type of a feature. Valid values are `Integral`, `Fractional`, or `String`.
        """
        if feature_name is not None:
            pulumi.set(__self__, "feature_name", feature_name)
        if feature_type is not None:
            pulumi.set(__self__, "feature_type", feature_type)

    @property
    @pulumi.getter(name="featureName")
    def feature_name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of a feature. `feature_name` cannot be any of the following: `is_deleted`, `write_time`, `api_invocation_time`.
        """
        return pulumi.get(self, "feature_name")

    @feature_name.setter
    def feature_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "feature_name", value)

    @property
    @pulumi.getter(name="featureType")
    def feature_type(self) -> Optional[pulumi.Input[str]]:
        """
        The value type of a feature. Valid values are `Integral`, `Fractional`, or `String`.
        """
        return pulumi.get(self, "feature_type")

    @feature_type.setter
    def feature_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "feature_type", value)


@pulumi.input_type
class FeatureGroupOfflineStoreConfigArgs:
    def __init__(__self__, *,
                 s3_storage_config: pulumi.Input['FeatureGroupOfflineStoreConfigS3StorageConfigArgs'],
                 data_catalog_config: Optional[pulumi.Input['FeatureGroupOfflineStoreConfigDataCatalogConfigArgs']] = None,
                 disable_glue_table_creation: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input['FeatureGroupOfflineStoreConfigS3StorageConfigArgs'] s3_storage_config: The Amazon Simple Storage (Amazon S3) location of OfflineStore. See S3 Storage Config Below.
        :param pulumi.Input['FeatureGroupOfflineStoreConfigDataCatalogConfigArgs'] data_catalog_config: The meta data of the Glue table that is autogenerated when an OfflineStore is created. See Data Catalog Config Below.
        :param pulumi.Input[bool] disable_glue_table_creation: Set to `true` to turn Online Store On.
        """
        pulumi.set(__self__, "s3_storage_config", s3_storage_config)
        if data_catalog_config is not None:
            pulumi.set(__self__, "data_catalog_config", data_catalog_config)
        if disable_glue_table_creation is not None:
            pulumi.set(__self__, "disable_glue_table_creation", disable_glue_table_creation)

    @property
    @pulumi.getter(name="s3StorageConfig")
    def s3_storage_config(self) -> pulumi.Input['FeatureGroupOfflineStoreConfigS3StorageConfigArgs']:
        """
        The Amazon Simple Storage (Amazon S3) location of OfflineStore. See S3 Storage Config Below.
        """
        return pulumi.get(self, "s3_storage_config")

    @s3_storage_config.setter
    def s3_storage_config(self, value: pulumi.Input['FeatureGroupOfflineStoreConfigS3StorageConfigArgs']):
        pulumi.set(self, "s3_storage_config", value)

    @property
    @pulumi.getter(name="dataCatalogConfig")
    def data_catalog_config(self) -> Optional[pulumi.Input['FeatureGroupOfflineStoreConfigDataCatalogConfigArgs']]:
        """
        The meta data of the Glue table that is autogenerated when an OfflineStore is created. See Data Catalog Config Below.
        """
        return pulumi.get(self, "data_catalog_config")

    @data_catalog_config.setter
    def data_catalog_config(self, value: Optional[pulumi.Input['FeatureGroupOfflineStoreConfigDataCatalogConfigArgs']]):
        pulumi.set(self, "data_catalog_config", value)

    @property
    @pulumi.getter(name="disableGlueTableCreation")
    def disable_glue_table_creation(self) -> Optional[pulumi.Input[bool]]:
        """
        Set to `true` to turn Online Store On.
        """
        return pulumi.get(self, "disable_glue_table_creation")

    @disable_glue_table_creation.setter
    def disable_glue_table_creation(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disable_glue_table_creation", value)


@pulumi.input_type
class FeatureGroupOfflineStoreConfigDataCatalogConfigArgs:
    def __init__(__self__, *,
                 catalog: Optional[pulumi.Input[str]] = None,
                 database: Optional[pulumi.Input[str]] = None,
                 table_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] catalog: The name of the Glue table catalog.
        :param pulumi.Input[str] database: The name of the Glue table database.
        :param pulumi.Input[str] table_name: The name of the Glue table.
        """
        if catalog is not None:
            pulumi.set(__self__, "catalog", catalog)
        if database is not None:
            pulumi.set(__self__, "database", database)
        if table_name is not None:
            pulumi.set(__self__, "table_name", table_name)

    @property
    @pulumi.getter
    def catalog(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the Glue table catalog.
        """
        return pulumi.get(self, "catalog")

    @catalog.setter
    def catalog(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "catalog", value)

    @property
    @pulumi.getter
    def database(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the Glue table database.
        """
        return pulumi.get(self, "database")

    @database.setter
    def database(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "database", value)

    @property
    @pulumi.getter(name="tableName")
    def table_name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the Glue table.
        """
        return pulumi.get(self, "table_name")

    @table_name.setter
    def table_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "table_name", value)


@pulumi.input_type
class FeatureGroupOfflineStoreConfigS3StorageConfigArgs:
    def __init__(__self__, *,
                 s3_uri: pulumi.Input[str],
                 kms_key_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] s3_uri: The S3 URI, or location in Amazon S3, of OfflineStore.
        :param pulumi.Input[str] kms_key_id: The ID of the AWS Key Management Service (AWS KMS) key that SageMaker Feature Store uses to encrypt the Amazon S3 objects at rest using Amazon S3 server-side encryption.
        """
        pulumi.set(__self__, "s3_uri", s3_uri)
        if kms_key_id is not None:
            pulumi.set(__self__, "kms_key_id", kms_key_id)

    @property
    @pulumi.getter(name="s3Uri")
    def s3_uri(self) -> pulumi.Input[str]:
        """
        The S3 URI, or location in Amazon S3, of OfflineStore.
        """
        return pulumi.get(self, "s3_uri")

    @s3_uri.setter
    def s3_uri(self, value: pulumi.Input[str]):
        pulumi.set(self, "s3_uri", value)

    @property
    @pulumi.getter(name="kmsKeyId")
    def kms_key_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the AWS Key Management Service (AWS KMS) key that SageMaker Feature Store uses to encrypt the Amazon S3 objects at rest using Amazon S3 server-side encryption.
        """
        return pulumi.get(self, "kms_key_id")

    @kms_key_id.setter
    def kms_key_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key_id", value)


@pulumi.input_type
class FeatureGroupOnlineStoreConfigArgs:
    def __init__(__self__, *,
                 enable_online_store: Optional[pulumi.Input[bool]] = None,
                 security_config: Optional[pulumi.Input['FeatureGroupOnlineStoreConfigSecurityConfigArgs']] = None):
        """
        :param pulumi.Input[bool] enable_online_store: Set to `true` to disable the automatic creation of an AWS Glue table when configuring an OfflineStore.
        :param pulumi.Input['FeatureGroupOnlineStoreConfigSecurityConfigArgs'] security_config: Security config for at-rest encryption of your OnlineStore. See Security Config Below.
        """
        if enable_online_store is not None:
            pulumi.set(__self__, "enable_online_store", enable_online_store)
        if security_config is not None:
            pulumi.set(__self__, "security_config", security_config)

    @property
    @pulumi.getter(name="enableOnlineStore")
    def enable_online_store(self) -> Optional[pulumi.Input[bool]]:
        """
        Set to `true` to disable the automatic creation of an AWS Glue table when configuring an OfflineStore.
        """
        return pulumi.get(self, "enable_online_store")

    @enable_online_store.setter
    def enable_online_store(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_online_store", value)

    @property
    @pulumi.getter(name="securityConfig")
    def security_config(self) -> Optional[pulumi.Input['FeatureGroupOnlineStoreConfigSecurityConfigArgs']]:
        """
        Security config for at-rest encryption of your OnlineStore. See Security Config Below.
        """
        return pulumi.get(self, "security_config")

    @security_config.setter
    def security_config(self, value: Optional[pulumi.Input['FeatureGroupOnlineStoreConfigSecurityConfigArgs']]):
        pulumi.set(self, "security_config", value)


@pulumi.input_type
class FeatureGroupOnlineStoreConfigSecurityConfigArgs:
    def __init__(__self__, *,
                 kms_key_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] kms_key_id: The ID of the AWS Key Management Service (AWS KMS) key that SageMaker Feature Store uses to encrypt the Amazon S3 objects at rest using Amazon S3 server-side encryption.
        """
        if kms_key_id is not None:
            pulumi.set(__self__, "kms_key_id", kms_key_id)

    @property
    @pulumi.getter(name="kmsKeyId")
    def kms_key_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the AWS Key Management Service (AWS KMS) key that SageMaker Feature Store uses to encrypt the Amazon S3 objects at rest using Amazon S3 server-side encryption.
        """
        return pulumi.get(self, "kms_key_id")

    @kms_key_id.setter
    def kms_key_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key_id", value)


@pulumi.input_type
class FlowDefinitionHumanLoopActivationConfigArgs:
    def __init__(__self__, *,
                 human_loop_activation_conditions_config: Optional[pulumi.Input['FlowDefinitionHumanLoopActivationConfigHumanLoopActivationConditionsConfigArgs']] = None):
        """
        :param pulumi.Input['FlowDefinitionHumanLoopActivationConfigHumanLoopActivationConditionsConfigArgs'] human_loop_activation_conditions_config: defines under what conditions SageMaker creates a human loop. See Human Loop Activation Conditions Config details below.
        """
        if human_loop_activation_conditions_config is not None:
            pulumi.set(__self__, "human_loop_activation_conditions_config", human_loop_activation_conditions_config)

    @property
    @pulumi.getter(name="humanLoopActivationConditionsConfig")
    def human_loop_activation_conditions_config(self) -> Optional[pulumi.Input['FlowDefinitionHumanLoopActivationConfigHumanLoopActivationConditionsConfigArgs']]:
        """
        defines under what conditions SageMaker creates a human loop. See Human Loop Activation Conditions Config details below.
        """
        return pulumi.get(self, "human_loop_activation_conditions_config")

    @human_loop_activation_conditions_config.setter
    def human_loop_activation_conditions_config(self, value: Optional[pulumi.Input['FlowDefinitionHumanLoopActivationConfigHumanLoopActivationConditionsConfigArgs']]):
        pulumi.set(self, "human_loop_activation_conditions_config", value)


@pulumi.input_type
class FlowDefinitionHumanLoopActivationConfigHumanLoopActivationConditionsConfigArgs:
    def __init__(__self__, *,
                 human_loop_activation_conditions: pulumi.Input[str]):
        """
        :param pulumi.Input[str] human_loop_activation_conditions: A JSON expressing use-case specific conditions declaratively. If any condition is matched, atomic tasks are created against the configured work team. For more information about how to structure the JSON, see [JSON Schema for Human Loop Activation Conditions in Amazon Augmented AI](https://docs.aws.amazon.com/sagemaker/latest/dg/a2i-human-fallback-conditions-json-schema.html).
        """
        pulumi.set(__self__, "human_loop_activation_conditions", human_loop_activation_conditions)

    @property
    @pulumi.getter(name="humanLoopActivationConditions")
    def human_loop_activation_conditions(self) -> pulumi.Input[str]:
        """
        A JSON expressing use-case specific conditions declaratively. If any condition is matched, atomic tasks are created against the configured work team. For more information about how to structure the JSON, see [JSON Schema for Human Loop Activation Conditions in Amazon Augmented AI](https://docs.aws.amazon.com/sagemaker/latest/dg/a2i-human-fallback-conditions-json-schema.html).
        """
        return pulumi.get(self, "human_loop_activation_conditions")

    @human_loop_activation_conditions.setter
    def human_loop_activation_conditions(self, value: pulumi.Input[str]):
        pulumi.set(self, "human_loop_activation_conditions", value)


@pulumi.input_type
class FlowDefinitionHumanLoopConfigArgs:
    def __init__(__self__, *,
                 human_task_ui_arn: pulumi.Input[str],
                 task_count: pulumi.Input[int],
                 task_description: pulumi.Input[str],
                 task_title: pulumi.Input[str],
                 workteam_arn: pulumi.Input[str],
                 public_workforce_task_price: Optional[pulumi.Input['FlowDefinitionHumanLoopConfigPublicWorkforceTaskPriceArgs']] = None,
                 task_availability_lifetime_in_seconds: Optional[pulumi.Input[int]] = None,
                 task_keywords: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 task_time_limit_in_seconds: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] human_task_ui_arn: The Amazon Resource Name (ARN) of the human task user interface.
        :param pulumi.Input[int] task_count: The number of distinct workers who will perform the same task on each object. Valid value range between `1` and `3`.
        :param pulumi.Input[str] task_description: A description for the human worker task.
        :param pulumi.Input[str] task_title: A title for the human worker task.
        :param pulumi.Input[str] workteam_arn: The Amazon Resource Name (ARN) of the human task user interface. Amazon Resource Name (ARN) of a team of workers. For Public workforces see [AWS Docs](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-workforce-management-public.html).
        :param pulumi.Input['FlowDefinitionHumanLoopConfigPublicWorkforceTaskPriceArgs'] public_workforce_task_price: Defines the amount of money paid to an Amazon Mechanical Turk worker for each task performed. See Public Workforce Task Price details below.
        :param pulumi.Input[int] task_availability_lifetime_in_seconds: The length of time that a task remains available for review by human workers. Valid value range between `1` and `864000`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] task_keywords: An array of keywords used to describe the task so that workers can discover the task.
        :param pulumi.Input[int] task_time_limit_in_seconds: The amount of time that a worker has to complete a task. The default value is `3600` seconds.
        """
        pulumi.set(__self__, "human_task_ui_arn", human_task_ui_arn)
        pulumi.set(__self__, "task_count", task_count)
        pulumi.set(__self__, "task_description", task_description)
        pulumi.set(__self__, "task_title", task_title)
        pulumi.set(__self__, "workteam_arn", workteam_arn)
        if public_workforce_task_price is not None:
            pulumi.set(__self__, "public_workforce_task_price", public_workforce_task_price)
        if task_availability_lifetime_in_seconds is not None:
            pulumi.set(__self__, "task_availability_lifetime_in_seconds", task_availability_lifetime_in_seconds)
        if task_keywords is not None:
            pulumi.set(__self__, "task_keywords", task_keywords)
        if task_time_limit_in_seconds is not None:
            pulumi.set(__self__, "task_time_limit_in_seconds", task_time_limit_in_seconds)

    @property
    @pulumi.getter(name="humanTaskUiArn")
    def human_task_ui_arn(self) -> pulumi.Input[str]:
        """
        The Amazon Resource Name (ARN) of the human task user interface.
        """
        return pulumi.get(self, "human_task_ui_arn")

    @human_task_ui_arn.setter
    def human_task_ui_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "human_task_ui_arn", value)

    @property
    @pulumi.getter(name="taskCount")
    def task_count(self) -> pulumi.Input[int]:
        """
        The number of distinct workers who will perform the same task on each object. Valid value range between `1` and `3`.
        """
        return pulumi.get(self, "task_count")

    @task_count.setter
    def task_count(self, value: pulumi.Input[int]):
        pulumi.set(self, "task_count", value)

    @property
    @pulumi.getter(name="taskDescription")
    def task_description(self) -> pulumi.Input[str]:
        """
        A description for the human worker task.
        """
        return pulumi.get(self, "task_description")

    @task_description.setter
    def task_description(self, value: pulumi.Input[str]):
        pulumi.set(self, "task_description", value)

    @property
    @pulumi.getter(name="taskTitle")
    def task_title(self) -> pulumi.Input[str]:
        """
        A title for the human worker task.
        """
        return pulumi.get(self, "task_title")

    @task_title.setter
    def task_title(self, value: pulumi.Input[str]):
        pulumi.set(self, "task_title", value)

    @property
    @pulumi.getter(name="workteamArn")
    def workteam_arn(self) -> pulumi.Input[str]:
        """
        The Amazon Resource Name (ARN) of the human task user interface. Amazon Resource Name (ARN) of a team of workers. For Public workforces see [AWS Docs](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-workforce-management-public.html).
        """
        return pulumi.get(self, "workteam_arn")

    @workteam_arn.setter
    def workteam_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "workteam_arn", value)

    @property
    @pulumi.getter(name="publicWorkforceTaskPrice")
    def public_workforce_task_price(self) -> Optional[pulumi.Input['FlowDefinitionHumanLoopConfigPublicWorkforceTaskPriceArgs']]:
        """
        Defines the amount of money paid to an Amazon Mechanical Turk worker for each task performed. See Public Workforce Task Price details below.
        """
        return pulumi.get(self, "public_workforce_task_price")

    @public_workforce_task_price.setter
    def public_workforce_task_price(self, value: Optional[pulumi.Input['FlowDefinitionHumanLoopConfigPublicWorkforceTaskPriceArgs']]):
        pulumi.set(self, "public_workforce_task_price", value)

    @property
    @pulumi.getter(name="taskAvailabilityLifetimeInSeconds")
    def task_availability_lifetime_in_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        The length of time that a task remains available for review by human workers. Valid value range between `1` and `864000`.
        """
        return pulumi.get(self, "task_availability_lifetime_in_seconds")

    @task_availability_lifetime_in_seconds.setter
    def task_availability_lifetime_in_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "task_availability_lifetime_in_seconds", value)

    @property
    @pulumi.getter(name="taskKeywords")
    def task_keywords(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        An array of keywords used to describe the task so that workers can discover the task.
        """
        return pulumi.get(self, "task_keywords")

    @task_keywords.setter
    def task_keywords(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "task_keywords", value)

    @property
    @pulumi.getter(name="taskTimeLimitInSeconds")
    def task_time_limit_in_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        The amount of time that a worker has to complete a task. The default value is `3600` seconds.
        """
        return pulumi.get(self, "task_time_limit_in_seconds")

    @task_time_limit_in_seconds.setter
    def task_time_limit_in_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "task_time_limit_in_seconds", value)


@pulumi.input_type
class FlowDefinitionHumanLoopConfigPublicWorkforceTaskPriceArgs:
    def __init__(__self__, *,
                 amount_in_usd: Optional[pulumi.Input['FlowDefinitionHumanLoopConfigPublicWorkforceTaskPriceAmountInUsdArgs']] = None):
        """
        :param pulumi.Input['FlowDefinitionHumanLoopConfigPublicWorkforceTaskPriceAmountInUsdArgs'] amount_in_usd: Defines the amount of money paid to an Amazon Mechanical Turk worker in United States dollars. See Amount In Usd details below.
        """
        if amount_in_usd is not None:
            pulumi.set(__self__, "amount_in_usd", amount_in_usd)

    @property
    @pulumi.getter(name="amountInUsd")
    def amount_in_usd(self) -> Optional[pulumi.Input['FlowDefinitionHumanLoopConfigPublicWorkforceTaskPriceAmountInUsdArgs']]:
        """
        Defines the amount of money paid to an Amazon Mechanical Turk worker in United States dollars. See Amount In Usd details below.
        """
        return pulumi.get(self, "amount_in_usd")

    @amount_in_usd.setter
    def amount_in_usd(self, value: Optional[pulumi.Input['FlowDefinitionHumanLoopConfigPublicWorkforceTaskPriceAmountInUsdArgs']]):
        pulumi.set(self, "amount_in_usd", value)


@pulumi.input_type
class FlowDefinitionHumanLoopConfigPublicWorkforceTaskPriceAmountInUsdArgs:
    def __init__(__self__, *,
                 cents: Optional[pulumi.Input[int]] = None,
                 dollars: Optional[pulumi.Input[int]] = None,
                 tenth_fractions_of_a_cent: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] cents: The fractional portion, in cents, of the amount. Valid value range between `0` and `99`.
        :param pulumi.Input[int] dollars: The whole number of dollars in the amount. Valid value range between `0` and `2`.
        :param pulumi.Input[int] tenth_fractions_of_a_cent: Fractions of a cent, in tenths. Valid value range between `0` and `9`.
        """
        if cents is not None:
            pulumi.set(__self__, "cents", cents)
        if dollars is not None:
            pulumi.set(__self__, "dollars", dollars)
        if tenth_fractions_of_a_cent is not None:
            pulumi.set(__self__, "tenth_fractions_of_a_cent", tenth_fractions_of_a_cent)

    @property
    @pulumi.getter
    def cents(self) -> Optional[pulumi.Input[int]]:
        """
        The fractional portion, in cents, of the amount. Valid value range between `0` and `99`.
        """
        return pulumi.get(self, "cents")

    @cents.setter
    def cents(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "cents", value)

    @property
    @pulumi.getter
    def dollars(self) -> Optional[pulumi.Input[int]]:
        """
        The whole number of dollars in the amount. Valid value range between `0` and `2`.
        """
        return pulumi.get(self, "dollars")

    @dollars.setter
    def dollars(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "dollars", value)

    @property
    @pulumi.getter(name="tenthFractionsOfACent")
    def tenth_fractions_of_a_cent(self) -> Optional[pulumi.Input[int]]:
        """
        Fractions of a cent, in tenths. Valid value range between `0` and `9`.
        """
        return pulumi.get(self, "tenth_fractions_of_a_cent")

    @tenth_fractions_of_a_cent.setter
    def tenth_fractions_of_a_cent(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "tenth_fractions_of_a_cent", value)


@pulumi.input_type
class FlowDefinitionHumanLoopRequestSourceArgs:
    def __init__(__self__, *,
                 aws_managed_human_loop_request_source: pulumi.Input[str]):
        """
        :param pulumi.Input[str] aws_managed_human_loop_request_source: Specifies whether Amazon Rekognition or Amazon Textract are used as the integration source. Valid values are: `AWS/Rekognition/DetectModerationLabels/Image/V3` and `AWS/Textract/AnalyzeDocument/Forms/V1`.
        """
        pulumi.set(__self__, "aws_managed_human_loop_request_source", aws_managed_human_loop_request_source)

    @property
    @pulumi.getter(name="awsManagedHumanLoopRequestSource")
    def aws_managed_human_loop_request_source(self) -> pulumi.Input[str]:
        """
        Specifies whether Amazon Rekognition or Amazon Textract are used as the integration source. Valid values are: `AWS/Rekognition/DetectModerationLabels/Image/V3` and `AWS/Textract/AnalyzeDocument/Forms/V1`.
        """
        return pulumi.get(self, "aws_managed_human_loop_request_source")

    @aws_managed_human_loop_request_source.setter
    def aws_managed_human_loop_request_source(self, value: pulumi.Input[str]):
        pulumi.set(self, "aws_managed_human_loop_request_source", value)


@pulumi.input_type
class FlowDefinitionOutputConfigArgs:
    def __init__(__self__, *,
                 s3_output_path: pulumi.Input[str],
                 kms_key_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] s3_output_path: The Amazon S3 path where the object containing human output will be made available.
        :param pulumi.Input[str] kms_key_id: The Amazon Key Management Service (KMS) key ARN for server-side encryption.
        """
        pulumi.set(__self__, "s3_output_path", s3_output_path)
        if kms_key_id is not None:
            pulumi.set(__self__, "kms_key_id", kms_key_id)

    @property
    @pulumi.getter(name="s3OutputPath")
    def s3_output_path(self) -> pulumi.Input[str]:
        """
        The Amazon S3 path where the object containing human output will be made available.
        """
        return pulumi.get(self, "s3_output_path")

    @s3_output_path.setter
    def s3_output_path(self, value: pulumi.Input[str]):
        pulumi.set(self, "s3_output_path", value)

    @property
    @pulumi.getter(name="kmsKeyId")
    def kms_key_id(self) -> Optional[pulumi.Input[str]]:
        """
        The Amazon Key Management Service (KMS) key ARN for server-side encryption.
        """
        return pulumi.get(self, "kms_key_id")

    @kms_key_id.setter
    def kms_key_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key_id", value)


@pulumi.input_type
class HumanTaskUIUiTemplateArgs:
    def __init__(__self__, *,
                 content: Optional[pulumi.Input[str]] = None,
                 content_sha256: Optional[pulumi.Input[str]] = None,
                 url: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] content: The content of the Liquid template for the worker user interface.
        :param pulumi.Input[str] content_sha256: The SHA-256 digest of the contents of the template.
        :param pulumi.Input[str] url: The URL for the user interface template.
        """
        if content is not None:
            pulumi.set(__self__, "content", content)
        if content_sha256 is not None:
            pulumi.set(__self__, "content_sha256", content_sha256)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def content(self) -> Optional[pulumi.Input[str]]:
        """
        The content of the Liquid template for the worker user interface.
        """
        return pulumi.get(self, "content")

    @content.setter
    def content(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "content", value)

    @property
    @pulumi.getter(name="contentSha256")
    def content_sha256(self) -> Optional[pulumi.Input[str]]:
        """
        The SHA-256 digest of the contents of the template.
        """
        return pulumi.get(self, "content_sha256")

    @content_sha256.setter
    def content_sha256(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "content_sha256", value)

    @property
    @pulumi.getter
    def url(self) -> Optional[pulumi.Input[str]]:
        """
        The URL for the user interface template.
        """
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "url", value)


@pulumi.input_type
class ModelContainerArgs:
    def __init__(__self__, *,
                 image: pulumi.Input[str],
                 container_hostname: Optional[pulumi.Input[str]] = None,
                 environment: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 image_config: Optional[pulumi.Input['ModelContainerImageConfigArgs']] = None,
                 mode: Optional[pulumi.Input[str]] = None,
                 model_data_url: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] image: The registry path where the inference code image is stored in Amazon ECR.
        :param pulumi.Input[str] container_hostname: The DNS host name for the container.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] environment: Environment variables for the Docker container.
               A list of key value pairs.
        :param pulumi.Input['ModelContainerImageConfigArgs'] image_config: Specifies whether the model container is in Amazon ECR or a private Docker registry accessible from your Amazon Virtual Private Cloud (VPC). For more information see [Using a Private Docker Registry for Real-Time Inference Containers](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-containers-inference-private.html). see Image Config.
        :param pulumi.Input[str] mode: The container hosts value `SingleModel/MultiModel`. The default value is `SingleModel`.
        :param pulumi.Input[str] model_data_url: The URL for the S3 location where model artifacts are stored.
        """
        pulumi.set(__self__, "image", image)
        if container_hostname is not None:
            pulumi.set(__self__, "container_hostname", container_hostname)
        if environment is not None:
            pulumi.set(__self__, "environment", environment)
        if image_config is not None:
            pulumi.set(__self__, "image_config", image_config)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if model_data_url is not None:
            pulumi.set(__self__, "model_data_url", model_data_url)

    @property
    @pulumi.getter
    def image(self) -> pulumi.Input[str]:
        """
        The registry path where the inference code image is stored in Amazon ECR.
        """
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: pulumi.Input[str]):
        pulumi.set(self, "image", value)

    @property
    @pulumi.getter(name="containerHostname")
    def container_hostname(self) -> Optional[pulumi.Input[str]]:
        """
        The DNS host name for the container.
        """
        return pulumi.get(self, "container_hostname")

    @container_hostname.setter
    def container_hostname(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "container_hostname", value)

    @property
    @pulumi.getter
    def environment(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        Environment variables for the Docker container.
        A list of key value pairs.
        """
        return pulumi.get(self, "environment")

    @environment.setter
    def environment(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "environment", value)

    @property
    @pulumi.getter(name="imageConfig")
    def image_config(self) -> Optional[pulumi.Input['ModelContainerImageConfigArgs']]:
        """
        Specifies whether the model container is in Amazon ECR or a private Docker registry accessible from your Amazon Virtual Private Cloud (VPC). For more information see [Using a Private Docker Registry for Real-Time Inference Containers](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-containers-inference-private.html). see Image Config.
        """
        return pulumi.get(self, "image_config")

    @image_config.setter
    def image_config(self, value: Optional[pulumi.Input['ModelContainerImageConfigArgs']]):
        pulumi.set(self, "image_config", value)

    @property
    @pulumi.getter
    def mode(self) -> Optional[pulumi.Input[str]]:
        """
        The container hosts value `SingleModel/MultiModel`. The default value is `SingleModel`.
        """
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mode", value)

    @property
    @pulumi.getter(name="modelDataUrl")
    def model_data_url(self) -> Optional[pulumi.Input[str]]:
        """
        The URL for the S3 location where model artifacts are stored.
        """
        return pulumi.get(self, "model_data_url")

    @model_data_url.setter
    def model_data_url(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "model_data_url", value)


@pulumi.input_type
class ModelContainerImageConfigArgs:
    def __init__(__self__, *,
                 repository_access_mode: pulumi.Input[str]):
        """
        :param pulumi.Input[str] repository_access_mode: Specifies whether the model container is in Amazon ECR or a private Docker registry accessible from your Amazon Virtual Private Cloud (VPC). Allowed values are: `Platform` and `Vpc`.
        """
        pulumi.set(__self__, "repository_access_mode", repository_access_mode)

    @property
    @pulumi.getter(name="repositoryAccessMode")
    def repository_access_mode(self) -> pulumi.Input[str]:
        """
        Specifies whether the model container is in Amazon ECR or a private Docker registry accessible from your Amazon Virtual Private Cloud (VPC). Allowed values are: `Platform` and `Vpc`.
        """
        return pulumi.get(self, "repository_access_mode")

    @repository_access_mode.setter
    def repository_access_mode(self, value: pulumi.Input[str]):
        pulumi.set(self, "repository_access_mode", value)


@pulumi.input_type
class ModelInferenceExecutionConfigArgs:
    def __init__(__self__, *,
                 mode: pulumi.Input[str]):
        """
        :param pulumi.Input[str] mode: The container hosts value `SingleModel/MultiModel`. The default value is `SingleModel`.
        """
        pulumi.set(__self__, "mode", mode)

    @property
    @pulumi.getter
    def mode(self) -> pulumi.Input[str]:
        """
        The container hosts value `SingleModel/MultiModel`. The default value is `SingleModel`.
        """
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: pulumi.Input[str]):
        pulumi.set(self, "mode", value)


@pulumi.input_type
class ModelPrimaryContainerArgs:
    def __init__(__self__, *,
                 image: pulumi.Input[str],
                 container_hostname: Optional[pulumi.Input[str]] = None,
                 environment: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 image_config: Optional[pulumi.Input['ModelPrimaryContainerImageConfigArgs']] = None,
                 mode: Optional[pulumi.Input[str]] = None,
                 model_data_url: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] image: The registry path where the inference code image is stored in Amazon ECR.
        :param pulumi.Input[str] container_hostname: The DNS host name for the container.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] environment: Environment variables for the Docker container.
               A list of key value pairs.
        :param pulumi.Input['ModelPrimaryContainerImageConfigArgs'] image_config: Specifies whether the model container is in Amazon ECR or a private Docker registry accessible from your Amazon Virtual Private Cloud (VPC). For more information see [Using a Private Docker Registry for Real-Time Inference Containers](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-containers-inference-private.html). see Image Config.
        :param pulumi.Input[str] mode: The container hosts value `SingleModel/MultiModel`. The default value is `SingleModel`.
        :param pulumi.Input[str] model_data_url: The URL for the S3 location where model artifacts are stored.
        """
        pulumi.set(__self__, "image", image)
        if container_hostname is not None:
            pulumi.set(__self__, "container_hostname", container_hostname)
        if environment is not None:
            pulumi.set(__self__, "environment", environment)
        if image_config is not None:
            pulumi.set(__self__, "image_config", image_config)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if model_data_url is not None:
            pulumi.set(__self__, "model_data_url", model_data_url)

    @property
    @pulumi.getter
    def image(self) -> pulumi.Input[str]:
        """
        The registry path where the inference code image is stored in Amazon ECR.
        """
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: pulumi.Input[str]):
        pulumi.set(self, "image", value)

    @property
    @pulumi.getter(name="containerHostname")
    def container_hostname(self) -> Optional[pulumi.Input[str]]:
        """
        The DNS host name for the container.
        """
        return pulumi.get(self, "container_hostname")

    @container_hostname.setter
    def container_hostname(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "container_hostname", value)

    @property
    @pulumi.getter
    def environment(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        Environment variables for the Docker container.
        A list of key value pairs.
        """
        return pulumi.get(self, "environment")

    @environment.setter
    def environment(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "environment", value)

    @property
    @pulumi.getter(name="imageConfig")
    def image_config(self) -> Optional[pulumi.Input['ModelPrimaryContainerImageConfigArgs']]:
        """
        Specifies whether the model container is in Amazon ECR or a private Docker registry accessible from your Amazon Virtual Private Cloud (VPC). For more information see [Using a Private Docker Registry for Real-Time Inference Containers](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-containers-inference-private.html). see Image Config.
        """
        return pulumi.get(self, "image_config")

    @image_config.setter
    def image_config(self, value: Optional[pulumi.Input['ModelPrimaryContainerImageConfigArgs']]):
        pulumi.set(self, "image_config", value)

    @property
    @pulumi.getter
    def mode(self) -> Optional[pulumi.Input[str]]:
        """
        The container hosts value `SingleModel/MultiModel`. The default value is `SingleModel`.
        """
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mode", value)

    @property
    @pulumi.getter(name="modelDataUrl")
    def model_data_url(self) -> Optional[pulumi.Input[str]]:
        """
        The URL for the S3 location where model artifacts are stored.
        """
        return pulumi.get(self, "model_data_url")

    @model_data_url.setter
    def model_data_url(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "model_data_url", value)


@pulumi.input_type
class ModelPrimaryContainerImageConfigArgs:
    def __init__(__self__, *,
                 repository_access_mode: pulumi.Input[str]):
        """
        :param pulumi.Input[str] repository_access_mode: Specifies whether the model container is in Amazon ECR or a private Docker registry accessible from your Amazon Virtual Private Cloud (VPC). Allowed values are: `Platform` and `Vpc`.
        """
        pulumi.set(__self__, "repository_access_mode", repository_access_mode)

    @property
    @pulumi.getter(name="repositoryAccessMode")
    def repository_access_mode(self) -> pulumi.Input[str]:
        """
        Specifies whether the model container is in Amazon ECR or a private Docker registry accessible from your Amazon Virtual Private Cloud (VPC). Allowed values are: `Platform` and `Vpc`.
        """
        return pulumi.get(self, "repository_access_mode")

    @repository_access_mode.setter
    def repository_access_mode(self, value: pulumi.Input[str]):
        pulumi.set(self, "repository_access_mode", value)


@pulumi.input_type
class ModelVpcConfigArgs:
    def __init__(__self__, *,
                 security_group_ids: pulumi.Input[Sequence[pulumi.Input[str]]],
                 subnets: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(__self__, "security_group_ids", security_group_ids)
        pulumi.set(__self__, "subnets", subnets)

    @property
    @pulumi.getter(name="securityGroupIds")
    def security_group_ids(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "security_group_ids")

    @security_group_ids.setter
    def security_group_ids(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "security_group_ids", value)

    @property
    @pulumi.getter
    def subnets(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "subnets")

    @subnets.setter
    def subnets(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "subnets", value)


@pulumi.input_type
class UserProfileUserSettingsArgs:
    def __init__(__self__, *,
                 execution_role: pulumi.Input[str],
                 jupyter_server_app_settings: Optional[pulumi.Input['UserProfileUserSettingsJupyterServerAppSettingsArgs']] = None,
                 kernel_gateway_app_settings: Optional[pulumi.Input['UserProfileUserSettingsKernelGatewayAppSettingsArgs']] = None,
                 security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 sharing_settings: Optional[pulumi.Input['UserProfileUserSettingsSharingSettingsArgs']] = None,
                 tensor_board_app_settings: Optional[pulumi.Input['UserProfileUserSettingsTensorBoardAppSettingsArgs']] = None):
        """
        :param pulumi.Input[str] execution_role: The execution role ARN for the user.
        :param pulumi.Input['UserProfileUserSettingsJupyterServerAppSettingsArgs'] jupyter_server_app_settings: The Jupyter server's app settings. See Jupyter Server App Settings below.
        :param pulumi.Input['UserProfileUserSettingsKernelGatewayAppSettingsArgs'] kernel_gateway_app_settings: The kernel gateway app settings. See Kernel Gateway App Settings below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] security_groups: The security groups.
        :param pulumi.Input['UserProfileUserSettingsSharingSettingsArgs'] sharing_settings: The sharing settings. See Sharing Settings below.
        :param pulumi.Input['UserProfileUserSettingsTensorBoardAppSettingsArgs'] tensor_board_app_settings: The TensorBoard app settings. See TensorBoard App Settings below.
        """
        pulumi.set(__self__, "execution_role", execution_role)
        if jupyter_server_app_settings is not None:
            pulumi.set(__self__, "jupyter_server_app_settings", jupyter_server_app_settings)
        if kernel_gateway_app_settings is not None:
            pulumi.set(__self__, "kernel_gateway_app_settings", kernel_gateway_app_settings)
        if security_groups is not None:
            pulumi.set(__self__, "security_groups", security_groups)
        if sharing_settings is not None:
            pulumi.set(__self__, "sharing_settings", sharing_settings)
        if tensor_board_app_settings is not None:
            pulumi.set(__self__, "tensor_board_app_settings", tensor_board_app_settings)

    @property
    @pulumi.getter(name="executionRole")
    def execution_role(self) -> pulumi.Input[str]:
        """
        The execution role ARN for the user.
        """
        return pulumi.get(self, "execution_role")

    @execution_role.setter
    def execution_role(self, value: pulumi.Input[str]):
        pulumi.set(self, "execution_role", value)

    @property
    @pulumi.getter(name="jupyterServerAppSettings")
    def jupyter_server_app_settings(self) -> Optional[pulumi.Input['UserProfileUserSettingsJupyterServerAppSettingsArgs']]:
        """
        The Jupyter server's app settings. See Jupyter Server App Settings below.
        """
        return pulumi.get(self, "jupyter_server_app_settings")

    @jupyter_server_app_settings.setter
    def jupyter_server_app_settings(self, value: Optional[pulumi.Input['UserProfileUserSettingsJupyterServerAppSettingsArgs']]):
        pulumi.set(self, "jupyter_server_app_settings", value)

    @property
    @pulumi.getter(name="kernelGatewayAppSettings")
    def kernel_gateway_app_settings(self) -> Optional[pulumi.Input['UserProfileUserSettingsKernelGatewayAppSettingsArgs']]:
        """
        The kernel gateway app settings. See Kernel Gateway App Settings below.
        """
        return pulumi.get(self, "kernel_gateway_app_settings")

    @kernel_gateway_app_settings.setter
    def kernel_gateway_app_settings(self, value: Optional[pulumi.Input['UserProfileUserSettingsKernelGatewayAppSettingsArgs']]):
        pulumi.set(self, "kernel_gateway_app_settings", value)

    @property
    @pulumi.getter(name="securityGroups")
    def security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The security groups.
        """
        return pulumi.get(self, "security_groups")

    @security_groups.setter
    def security_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "security_groups", value)

    @property
    @pulumi.getter(name="sharingSettings")
    def sharing_settings(self) -> Optional[pulumi.Input['UserProfileUserSettingsSharingSettingsArgs']]:
        """
        The sharing settings. See Sharing Settings below.
        """
        return pulumi.get(self, "sharing_settings")

    @sharing_settings.setter
    def sharing_settings(self, value: Optional[pulumi.Input['UserProfileUserSettingsSharingSettingsArgs']]):
        pulumi.set(self, "sharing_settings", value)

    @property
    @pulumi.getter(name="tensorBoardAppSettings")
    def tensor_board_app_settings(self) -> Optional[pulumi.Input['UserProfileUserSettingsTensorBoardAppSettingsArgs']]:
        """
        The TensorBoard app settings. See TensorBoard App Settings below.
        """
        return pulumi.get(self, "tensor_board_app_settings")

    @tensor_board_app_settings.setter
    def tensor_board_app_settings(self, value: Optional[pulumi.Input['UserProfileUserSettingsTensorBoardAppSettingsArgs']]):
        pulumi.set(self, "tensor_board_app_settings", value)


@pulumi.input_type
class UserProfileUserSettingsJupyterServerAppSettingsArgs:
    def __init__(__self__, *,
                 default_resource_spec: pulumi.Input['UserProfileUserSettingsJupyterServerAppSettingsDefaultResourceSpecArgs'],
                 lifecycle_config_arns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input['UserProfileUserSettingsJupyterServerAppSettingsDefaultResourceSpecArgs'] default_resource_spec: The default instance type and the Amazon Resource Name (ARN) of the SageMaker image created on the instance. see Default Resource Spec below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] lifecycle_config_arns: The Amazon Resource Name (ARN) of the Lifecycle Configurations.
        """
        pulumi.set(__self__, "default_resource_spec", default_resource_spec)
        if lifecycle_config_arns is not None:
            pulumi.set(__self__, "lifecycle_config_arns", lifecycle_config_arns)

    @property
    @pulumi.getter(name="defaultResourceSpec")
    def default_resource_spec(self) -> pulumi.Input['UserProfileUserSettingsJupyterServerAppSettingsDefaultResourceSpecArgs']:
        """
        The default instance type and the Amazon Resource Name (ARN) of the SageMaker image created on the instance. see Default Resource Spec below.
        """
        return pulumi.get(self, "default_resource_spec")

    @default_resource_spec.setter
    def default_resource_spec(self, value: pulumi.Input['UserProfileUserSettingsJupyterServerAppSettingsDefaultResourceSpecArgs']):
        pulumi.set(self, "default_resource_spec", value)

    @property
    @pulumi.getter(name="lifecycleConfigArns")
    def lifecycle_config_arns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The Amazon Resource Name (ARN) of the Lifecycle Configurations.
        """
        return pulumi.get(self, "lifecycle_config_arns")

    @lifecycle_config_arns.setter
    def lifecycle_config_arns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "lifecycle_config_arns", value)


@pulumi.input_type
class UserProfileUserSettingsJupyterServerAppSettingsDefaultResourceSpecArgs:
    def __init__(__self__, *,
                 instance_type: Optional[pulumi.Input[str]] = None,
                 sagemaker_image_arn: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] instance_type: The instance type.
        :param pulumi.Input[str] sagemaker_image_arn: The Amazon Resource Name (ARN) of the SageMaker image created on the instance.
        """
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if sagemaker_image_arn is not None:
            pulumi.set(__self__, "sagemaker_image_arn", sagemaker_image_arn)

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[pulumi.Input[str]]:
        """
        The instance type.
        """
        return pulumi.get(self, "instance_type")

    @instance_type.setter
    def instance_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "instance_type", value)

    @property
    @pulumi.getter(name="sagemakerImageArn")
    def sagemaker_image_arn(self) -> Optional[pulumi.Input[str]]:
        """
        The Amazon Resource Name (ARN) of the SageMaker image created on the instance.
        """
        return pulumi.get(self, "sagemaker_image_arn")

    @sagemaker_image_arn.setter
    def sagemaker_image_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sagemaker_image_arn", value)


@pulumi.input_type
class UserProfileUserSettingsKernelGatewayAppSettingsArgs:
    def __init__(__self__, *,
                 default_resource_spec: pulumi.Input['UserProfileUserSettingsKernelGatewayAppSettingsDefaultResourceSpecArgs'],
                 custom_images: Optional[pulumi.Input[Sequence[pulumi.Input['UserProfileUserSettingsKernelGatewayAppSettingsCustomImageArgs']]]] = None,
                 lifecycle_config_arns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input['UserProfileUserSettingsKernelGatewayAppSettingsDefaultResourceSpecArgs'] default_resource_spec: The default instance type and the Amazon Resource Name (ARN) of the SageMaker image created on the instance. see Default Resource Spec below.
        :param pulumi.Input[Sequence[pulumi.Input['UserProfileUserSettingsKernelGatewayAppSettingsCustomImageArgs']]] custom_images: A list of custom SageMaker images that are configured to run as a KernelGateway app. see Custom Image below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] lifecycle_config_arns: The Amazon Resource Name (ARN) of the Lifecycle Configurations.
        """
        pulumi.set(__self__, "default_resource_spec", default_resource_spec)
        if custom_images is not None:
            pulumi.set(__self__, "custom_images", custom_images)
        if lifecycle_config_arns is not None:
            pulumi.set(__self__, "lifecycle_config_arns", lifecycle_config_arns)

    @property
    @pulumi.getter(name="defaultResourceSpec")
    def default_resource_spec(self) -> pulumi.Input['UserProfileUserSettingsKernelGatewayAppSettingsDefaultResourceSpecArgs']:
        """
        The default instance type and the Amazon Resource Name (ARN) of the SageMaker image created on the instance. see Default Resource Spec below.
        """
        return pulumi.get(self, "default_resource_spec")

    @default_resource_spec.setter
    def default_resource_spec(self, value: pulumi.Input['UserProfileUserSettingsKernelGatewayAppSettingsDefaultResourceSpecArgs']):
        pulumi.set(self, "default_resource_spec", value)

    @property
    @pulumi.getter(name="customImages")
    def custom_images(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['UserProfileUserSettingsKernelGatewayAppSettingsCustomImageArgs']]]]:
        """
        A list of custom SageMaker images that are configured to run as a KernelGateway app. see Custom Image below.
        """
        return pulumi.get(self, "custom_images")

    @custom_images.setter
    def custom_images(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['UserProfileUserSettingsKernelGatewayAppSettingsCustomImageArgs']]]]):
        pulumi.set(self, "custom_images", value)

    @property
    @pulumi.getter(name="lifecycleConfigArns")
    def lifecycle_config_arns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The Amazon Resource Name (ARN) of the Lifecycle Configurations.
        """
        return pulumi.get(self, "lifecycle_config_arns")

    @lifecycle_config_arns.setter
    def lifecycle_config_arns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "lifecycle_config_arns", value)


@pulumi.input_type
class UserProfileUserSettingsKernelGatewayAppSettingsCustomImageArgs:
    def __init__(__self__, *,
                 app_image_config_name: pulumi.Input[str],
                 image_name: pulumi.Input[str],
                 image_version_number: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] app_image_config_name: The name of the App Image Config.
        :param pulumi.Input[str] image_name: The name of the Custom Image.
        :param pulumi.Input[int] image_version_number: The version number of the Custom Image.
        """
        pulumi.set(__self__, "app_image_config_name", app_image_config_name)
        pulumi.set(__self__, "image_name", image_name)
        if image_version_number is not None:
            pulumi.set(__self__, "image_version_number", image_version_number)

    @property
    @pulumi.getter(name="appImageConfigName")
    def app_image_config_name(self) -> pulumi.Input[str]:
        """
        The name of the App Image Config.
        """
        return pulumi.get(self, "app_image_config_name")

    @app_image_config_name.setter
    def app_image_config_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "app_image_config_name", value)

    @property
    @pulumi.getter(name="imageName")
    def image_name(self) -> pulumi.Input[str]:
        """
        The name of the Custom Image.
        """
        return pulumi.get(self, "image_name")

    @image_name.setter
    def image_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "image_name", value)

    @property
    @pulumi.getter(name="imageVersionNumber")
    def image_version_number(self) -> Optional[pulumi.Input[int]]:
        """
        The version number of the Custom Image.
        """
        return pulumi.get(self, "image_version_number")

    @image_version_number.setter
    def image_version_number(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "image_version_number", value)


@pulumi.input_type
class UserProfileUserSettingsKernelGatewayAppSettingsDefaultResourceSpecArgs:
    def __init__(__self__, *,
                 instance_type: Optional[pulumi.Input[str]] = None,
                 sagemaker_image_arn: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] instance_type: The instance type.
        :param pulumi.Input[str] sagemaker_image_arn: The Amazon Resource Name (ARN) of the SageMaker image created on the instance.
        """
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if sagemaker_image_arn is not None:
            pulumi.set(__self__, "sagemaker_image_arn", sagemaker_image_arn)

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[pulumi.Input[str]]:
        """
        The instance type.
        """
        return pulumi.get(self, "instance_type")

    @instance_type.setter
    def instance_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "instance_type", value)

    @property
    @pulumi.getter(name="sagemakerImageArn")
    def sagemaker_image_arn(self) -> Optional[pulumi.Input[str]]:
        """
        The Amazon Resource Name (ARN) of the SageMaker image created on the instance.
        """
        return pulumi.get(self, "sagemaker_image_arn")

    @sagemaker_image_arn.setter
    def sagemaker_image_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sagemaker_image_arn", value)


@pulumi.input_type
class UserProfileUserSettingsSharingSettingsArgs:
    def __init__(__self__, *,
                 notebook_output_option: Optional[pulumi.Input[str]] = None,
                 s3_kms_key_id: Optional[pulumi.Input[str]] = None,
                 s3_output_path: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] notebook_output_option: Whether to include the notebook cell output when sharing the notebook. The default is `Disabled`. Valid values are `Allowed` and `Disabled`.
        :param pulumi.Input[str] s3_kms_key_id: When `notebook_output_option` is Allowed, the AWS Key Management Service (KMS) encryption key ID used to encrypt the notebook cell output in the Amazon S3 bucket.
        :param pulumi.Input[str] s3_output_path: When `notebook_output_option` is Allowed, the Amazon S3 bucket used to save the notebook cell output.
        """
        if notebook_output_option is not None:
            pulumi.set(__self__, "notebook_output_option", notebook_output_option)
        if s3_kms_key_id is not None:
            pulumi.set(__self__, "s3_kms_key_id", s3_kms_key_id)
        if s3_output_path is not None:
            pulumi.set(__self__, "s3_output_path", s3_output_path)

    @property
    @pulumi.getter(name="notebookOutputOption")
    def notebook_output_option(self) -> Optional[pulumi.Input[str]]:
        """
        Whether to include the notebook cell output when sharing the notebook. The default is `Disabled`. Valid values are `Allowed` and `Disabled`.
        """
        return pulumi.get(self, "notebook_output_option")

    @notebook_output_option.setter
    def notebook_output_option(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "notebook_output_option", value)

    @property
    @pulumi.getter(name="s3KmsKeyId")
    def s3_kms_key_id(self) -> Optional[pulumi.Input[str]]:
        """
        When `notebook_output_option` is Allowed, the AWS Key Management Service (KMS) encryption key ID used to encrypt the notebook cell output in the Amazon S3 bucket.
        """
        return pulumi.get(self, "s3_kms_key_id")

    @s3_kms_key_id.setter
    def s3_kms_key_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "s3_kms_key_id", value)

    @property
    @pulumi.getter(name="s3OutputPath")
    def s3_output_path(self) -> Optional[pulumi.Input[str]]:
        """
        When `notebook_output_option` is Allowed, the Amazon S3 bucket used to save the notebook cell output.
        """
        return pulumi.get(self, "s3_output_path")

    @s3_output_path.setter
    def s3_output_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "s3_output_path", value)


@pulumi.input_type
class UserProfileUserSettingsTensorBoardAppSettingsArgs:
    def __init__(__self__, *,
                 default_resource_spec: pulumi.Input['UserProfileUserSettingsTensorBoardAppSettingsDefaultResourceSpecArgs']):
        """
        :param pulumi.Input['UserProfileUserSettingsTensorBoardAppSettingsDefaultResourceSpecArgs'] default_resource_spec: The default instance type and the Amazon Resource Name (ARN) of the SageMaker image created on the instance. see Default Resource Spec below.
        """
        pulumi.set(__self__, "default_resource_spec", default_resource_spec)

    @property
    @pulumi.getter(name="defaultResourceSpec")
    def default_resource_spec(self) -> pulumi.Input['UserProfileUserSettingsTensorBoardAppSettingsDefaultResourceSpecArgs']:
        """
        The default instance type and the Amazon Resource Name (ARN) of the SageMaker image created on the instance. see Default Resource Spec below.
        """
        return pulumi.get(self, "default_resource_spec")

    @default_resource_spec.setter
    def default_resource_spec(self, value: pulumi.Input['UserProfileUserSettingsTensorBoardAppSettingsDefaultResourceSpecArgs']):
        pulumi.set(self, "default_resource_spec", value)


@pulumi.input_type
class UserProfileUserSettingsTensorBoardAppSettingsDefaultResourceSpecArgs:
    def __init__(__self__, *,
                 instance_type: Optional[pulumi.Input[str]] = None,
                 sagemaker_image_arn: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] instance_type: The instance type.
        :param pulumi.Input[str] sagemaker_image_arn: The Amazon Resource Name (ARN) of the SageMaker image created on the instance.
        """
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if sagemaker_image_arn is not None:
            pulumi.set(__self__, "sagemaker_image_arn", sagemaker_image_arn)

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[pulumi.Input[str]]:
        """
        The instance type.
        """
        return pulumi.get(self, "instance_type")

    @instance_type.setter
    def instance_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "instance_type", value)

    @property
    @pulumi.getter(name="sagemakerImageArn")
    def sagemaker_image_arn(self) -> Optional[pulumi.Input[str]]:
        """
        The Amazon Resource Name (ARN) of the SageMaker image created on the instance.
        """
        return pulumi.get(self, "sagemaker_image_arn")

    @sagemaker_image_arn.setter
    def sagemaker_image_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sagemaker_image_arn", value)


@pulumi.input_type
class WorkforceCognitoConfigArgs:
    def __init__(__self__, *,
                 client_id: pulumi.Input[str],
                 user_pool: pulumi.Input[str]):
        """
        :param pulumi.Input[str] client_id: The OIDC IdP client ID used to configure your private workforce.
        :param pulumi.Input[str] user_pool: The id for your Amazon Cognito user pool.
        """
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "user_pool", user_pool)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> pulumi.Input[str]:
        """
        The OIDC IdP client ID used to configure your private workforce.
        """
        return pulumi.get(self, "client_id")

    @client_id.setter
    def client_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "client_id", value)

    @property
    @pulumi.getter(name="userPool")
    def user_pool(self) -> pulumi.Input[str]:
        """
        The id for your Amazon Cognito user pool.
        """
        return pulumi.get(self, "user_pool")

    @user_pool.setter
    def user_pool(self, value: pulumi.Input[str]):
        pulumi.set(self, "user_pool", value)


@pulumi.input_type
class WorkforceOidcConfigArgs:
    def __init__(__self__, *,
                 authorization_endpoint: pulumi.Input[str],
                 client_id: pulumi.Input[str],
                 client_secret: pulumi.Input[str],
                 issuer: pulumi.Input[str],
                 jwks_uri: pulumi.Input[str],
                 logout_endpoint: pulumi.Input[str],
                 token_endpoint: pulumi.Input[str],
                 user_info_endpoint: pulumi.Input[str]):
        """
        :param pulumi.Input[str] authorization_endpoint: The OIDC IdP authorization endpoint used to configure your private workforce.
        :param pulumi.Input[str] client_id: The OIDC IdP client ID used to configure your private workforce.
        :param pulumi.Input[str] client_secret: The OIDC IdP client secret used to configure your private workforce.
        :param pulumi.Input[str] issuer: The OIDC IdP issuer used to configure your private workforce.
        :param pulumi.Input[str] jwks_uri: The OIDC IdP JSON Web Key Set (Jwks) URI used to configure your private workforce.
        :param pulumi.Input[str] logout_endpoint: The OIDC IdP logout endpoint used to configure your private workforce.
        :param pulumi.Input[str] token_endpoint: The OIDC IdP token endpoint used to configure your private workforce.
        :param pulumi.Input[str] user_info_endpoint: The OIDC IdP user information endpoint used to configure your private workforce.
        """
        pulumi.set(__self__, "authorization_endpoint", authorization_endpoint)
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "client_secret", client_secret)
        pulumi.set(__self__, "issuer", issuer)
        pulumi.set(__self__, "jwks_uri", jwks_uri)
        pulumi.set(__self__, "logout_endpoint", logout_endpoint)
        pulumi.set(__self__, "token_endpoint", token_endpoint)
        pulumi.set(__self__, "user_info_endpoint", user_info_endpoint)

    @property
    @pulumi.getter(name="authorizationEndpoint")
    def authorization_endpoint(self) -> pulumi.Input[str]:
        """
        The OIDC IdP authorization endpoint used to configure your private workforce.
        """
        return pulumi.get(self, "authorization_endpoint")

    @authorization_endpoint.setter
    def authorization_endpoint(self, value: pulumi.Input[str]):
        pulumi.set(self, "authorization_endpoint", value)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> pulumi.Input[str]:
        """
        The OIDC IdP client ID used to configure your private workforce.
        """
        return pulumi.get(self, "client_id")

    @client_id.setter
    def client_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "client_id", value)

    @property
    @pulumi.getter(name="clientSecret")
    def client_secret(self) -> pulumi.Input[str]:
        """
        The OIDC IdP client secret used to configure your private workforce.
        """
        return pulumi.get(self, "client_secret")

    @client_secret.setter
    def client_secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "client_secret", value)

    @property
    @pulumi.getter
    def issuer(self) -> pulumi.Input[str]:
        """
        The OIDC IdP issuer used to configure your private workforce.
        """
        return pulumi.get(self, "issuer")

    @issuer.setter
    def issuer(self, value: pulumi.Input[str]):
        pulumi.set(self, "issuer", value)

    @property
    @pulumi.getter(name="jwksUri")
    def jwks_uri(self) -> pulumi.Input[str]:
        """
        The OIDC IdP JSON Web Key Set (Jwks) URI used to configure your private workforce.
        """
        return pulumi.get(self, "jwks_uri")

    @jwks_uri.setter
    def jwks_uri(self, value: pulumi.Input[str]):
        pulumi.set(self, "jwks_uri", value)

    @property
    @pulumi.getter(name="logoutEndpoint")
    def logout_endpoint(self) -> pulumi.Input[str]:
        """
        The OIDC IdP logout endpoint used to configure your private workforce.
        """
        return pulumi.get(self, "logout_endpoint")

    @logout_endpoint.setter
    def logout_endpoint(self, value: pulumi.Input[str]):
        pulumi.set(self, "logout_endpoint", value)

    @property
    @pulumi.getter(name="tokenEndpoint")
    def token_endpoint(self) -> pulumi.Input[str]:
        """
        The OIDC IdP token endpoint used to configure your private workforce.
        """
        return pulumi.get(self, "token_endpoint")

    @token_endpoint.setter
    def token_endpoint(self, value: pulumi.Input[str]):
        pulumi.set(self, "token_endpoint", value)

    @property
    @pulumi.getter(name="userInfoEndpoint")
    def user_info_endpoint(self) -> pulumi.Input[str]:
        """
        The OIDC IdP user information endpoint used to configure your private workforce.
        """
        return pulumi.get(self, "user_info_endpoint")

    @user_info_endpoint.setter
    def user_info_endpoint(self, value: pulumi.Input[str]):
        pulumi.set(self, "user_info_endpoint", value)


@pulumi.input_type
class WorkforceSourceIpConfigArgs:
    def __init__(__self__, *,
                 cidrs: pulumi.Input[Sequence[pulumi.Input[str]]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] cidrs: A list of up to 10 CIDR values.
        """
        pulumi.set(__self__, "cidrs", cidrs)

    @property
    @pulumi.getter
    def cidrs(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        A list of up to 10 CIDR values.
        """
        return pulumi.get(self, "cidrs")

    @cidrs.setter
    def cidrs(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "cidrs", value)


@pulumi.input_type
class WorkteamMemberDefinitionArgs:
    def __init__(__self__, *,
                 cognito_member_definition: Optional[pulumi.Input['WorkteamMemberDefinitionCognitoMemberDefinitionArgs']] = None,
                 oidc_member_definition: Optional[pulumi.Input['WorkteamMemberDefinitionOidcMemberDefinitionArgs']] = None):
        """
        :param pulumi.Input['WorkteamMemberDefinitionCognitoMemberDefinitionArgs'] cognito_member_definition: The Amazon Cognito user group that is part of the work team. See Cognito Member Definition details below.
        :param pulumi.Input['WorkteamMemberDefinitionOidcMemberDefinitionArgs'] oidc_member_definition: A list user groups that exist in your OIDC Identity Provider (IdP). One to ten groups can be used to create a single private work team. See Cognito Member Definition details below.
        """
        if cognito_member_definition is not None:
            pulumi.set(__self__, "cognito_member_definition", cognito_member_definition)
        if oidc_member_definition is not None:
            pulumi.set(__self__, "oidc_member_definition", oidc_member_definition)

    @property
    @pulumi.getter(name="cognitoMemberDefinition")
    def cognito_member_definition(self) -> Optional[pulumi.Input['WorkteamMemberDefinitionCognitoMemberDefinitionArgs']]:
        """
        The Amazon Cognito user group that is part of the work team. See Cognito Member Definition details below.
        """
        return pulumi.get(self, "cognito_member_definition")

    @cognito_member_definition.setter
    def cognito_member_definition(self, value: Optional[pulumi.Input['WorkteamMemberDefinitionCognitoMemberDefinitionArgs']]):
        pulumi.set(self, "cognito_member_definition", value)

    @property
    @pulumi.getter(name="oidcMemberDefinition")
    def oidc_member_definition(self) -> Optional[pulumi.Input['WorkteamMemberDefinitionOidcMemberDefinitionArgs']]:
        """
        A list user groups that exist in your OIDC Identity Provider (IdP). One to ten groups can be used to create a single private work team. See Cognito Member Definition details below.
        """
        return pulumi.get(self, "oidc_member_definition")

    @oidc_member_definition.setter
    def oidc_member_definition(self, value: Optional[pulumi.Input['WorkteamMemberDefinitionOidcMemberDefinitionArgs']]):
        pulumi.set(self, "oidc_member_definition", value)


@pulumi.input_type
class WorkteamMemberDefinitionCognitoMemberDefinitionArgs:
    def __init__(__self__, *,
                 client_id: pulumi.Input[str],
                 user_group: pulumi.Input[str],
                 user_pool: pulumi.Input[str]):
        """
        :param pulumi.Input[str] client_id: An identifier for an application client. You must create the app client ID using Amazon Cognito.
        :param pulumi.Input[str] user_group: An identifier for a user group.
        :param pulumi.Input[str] user_pool: An identifier for a user pool. The user pool must be in the same region as the service that you are calling.
        """
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "user_group", user_group)
        pulumi.set(__self__, "user_pool", user_pool)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> pulumi.Input[str]:
        """
        An identifier for an application client. You must create the app client ID using Amazon Cognito.
        """
        return pulumi.get(self, "client_id")

    @client_id.setter
    def client_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "client_id", value)

    @property
    @pulumi.getter(name="userGroup")
    def user_group(self) -> pulumi.Input[str]:
        """
        An identifier for a user group.
        """
        return pulumi.get(self, "user_group")

    @user_group.setter
    def user_group(self, value: pulumi.Input[str]):
        pulumi.set(self, "user_group", value)

    @property
    @pulumi.getter(name="userPool")
    def user_pool(self) -> pulumi.Input[str]:
        """
        An identifier for a user pool. The user pool must be in the same region as the service that you are calling.
        """
        return pulumi.get(self, "user_pool")

    @user_pool.setter
    def user_pool(self, value: pulumi.Input[str]):
        pulumi.set(self, "user_pool", value)


@pulumi.input_type
class WorkteamMemberDefinitionOidcMemberDefinitionArgs:
    def __init__(__self__, *,
                 groups: pulumi.Input[Sequence[pulumi.Input[str]]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] groups: A list of comma separated strings that identifies user groups in your OIDC IdP. Each user group is made up of a group of private workers.
        """
        pulumi.set(__self__, "groups", groups)

    @property
    @pulumi.getter
    def groups(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        A list of comma separated strings that identifies user groups in your OIDC IdP. Each user group is made up of a group of private workers.
        """
        return pulumi.get(self, "groups")

    @groups.setter
    def groups(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "groups", value)


@pulumi.input_type
class WorkteamNotificationConfigurationArgs:
    def __init__(__self__, *,
                 notification_topic_arn: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] notification_topic_arn: The ARN for the SNS topic to which notifications should be published.
        """
        if notification_topic_arn is not None:
            pulumi.set(__self__, "notification_topic_arn", notification_topic_arn)

    @property
    @pulumi.getter(name="notificationTopicArn")
    def notification_topic_arn(self) -> Optional[pulumi.Input[str]]:
        """
        The ARN for the SNS topic to which notifications should be published.
        """
        return pulumi.get(self, "notification_topic_arn")

    @notification_topic_arn.setter
    def notification_topic_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "notification_topic_arn", value)


