# 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
from . import outputs

__all__ = [
    'AppImageConfigKernelGatewayImageConfig',
    'AppImageConfigKernelGatewayImageConfigFileSystemConfig',
    'AppImageConfigKernelGatewayImageConfigKernelSpec',
    'AppResourceSpec',
    'CodeRepositoryGitConfig',
    'DeviceDevice',
    'DeviceFleetOutputConfig',
    'DomainDefaultUserSettings',
    'DomainDefaultUserSettingsJupyterServerAppSettings',
    'DomainDefaultUserSettingsJupyterServerAppSettingsDefaultResourceSpec',
    'DomainDefaultUserSettingsKernelGatewayAppSettings',
    'DomainDefaultUserSettingsKernelGatewayAppSettingsCustomImage',
    'DomainDefaultUserSettingsKernelGatewayAppSettingsDefaultResourceSpec',
    'DomainDefaultUserSettingsSharingSettings',
    'DomainDefaultUserSettingsTensorBoardAppSettings',
    'DomainDefaultUserSettingsTensorBoardAppSettingsDefaultResourceSpec',
    'DomainRetentionPolicy',
    'EndpointConfigurationAsyncInferenceConfig',
    'EndpointConfigurationAsyncInferenceConfigClientConfig',
    'EndpointConfigurationAsyncInferenceConfigOutputConfig',
    'EndpointConfigurationAsyncInferenceConfigOutputConfigNotificationConfig',
    'EndpointConfigurationDataCaptureConfig',
    'EndpointConfigurationDataCaptureConfigCaptureContentTypeHeader',
    'EndpointConfigurationDataCaptureConfigCaptureOption',
    'EndpointConfigurationProductionVariant',
    'EndpointDeploymentConfig',
    'EndpointDeploymentConfigAutoRollbackConfiguration',
    'EndpointDeploymentConfigAutoRollbackConfigurationAlarm',
    'EndpointDeploymentConfigBlueGreenUpdatePolicy',
    'EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfiguration',
    'EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfigurationCanarySize',
    'EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfigurationLinearStepSize',
    'FeatureGroupFeatureDefinition',
    'FeatureGroupOfflineStoreConfig',
    'FeatureGroupOfflineStoreConfigDataCatalogConfig',
    'FeatureGroupOfflineStoreConfigS3StorageConfig',
    'FeatureGroupOnlineStoreConfig',
    'FeatureGroupOnlineStoreConfigSecurityConfig',
    'FlowDefinitionHumanLoopActivationConfig',
    'FlowDefinitionHumanLoopActivationConfigHumanLoopActivationConditionsConfig',
    'FlowDefinitionHumanLoopConfig',
    'FlowDefinitionHumanLoopConfigPublicWorkforceTaskPrice',
    'FlowDefinitionHumanLoopConfigPublicWorkforceTaskPriceAmountInUsd',
    'FlowDefinitionHumanLoopRequestSource',
    'FlowDefinitionOutputConfig',
    'HumanTaskUIUiTemplate',
    'ModelContainer',
    'ModelContainerImageConfig',
    'ModelInferenceExecutionConfig',
    'ModelPrimaryContainer',
    'ModelPrimaryContainerImageConfig',
    'ModelVpcConfig',
    'ProjectServiceCatalogProvisioningDetails',
    'ProjectServiceCatalogProvisioningDetailsProvisioningParameter',
    'UserProfileUserSettings',
    'UserProfileUserSettingsJupyterServerAppSettings',
    'UserProfileUserSettingsJupyterServerAppSettingsDefaultResourceSpec',
    'UserProfileUserSettingsKernelGatewayAppSettings',
    'UserProfileUserSettingsKernelGatewayAppSettingsCustomImage',
    'UserProfileUserSettingsKernelGatewayAppSettingsDefaultResourceSpec',
    'UserProfileUserSettingsSharingSettings',
    'UserProfileUserSettingsTensorBoardAppSettings',
    'UserProfileUserSettingsTensorBoardAppSettingsDefaultResourceSpec',
    'WorkforceCognitoConfig',
    'WorkforceOidcConfig',
    'WorkforceSourceIpConfig',
    'WorkteamMemberDefinition',
    'WorkteamMemberDefinitionCognitoMemberDefinition',
    'WorkteamMemberDefinitionOidcMemberDefinition',
    'WorkteamNotificationConfiguration',
]

@pulumi.output_type
class AppImageConfigKernelGatewayImageConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kernelSpec":
            suggest = "kernel_spec"
        elif key == "fileSystemConfig":
            suggest = "file_system_config"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AppImageConfigKernelGatewayImageConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AppImageConfigKernelGatewayImageConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AppImageConfigKernelGatewayImageConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kernel_spec: 'outputs.AppImageConfigKernelGatewayImageConfigKernelSpec',
                 file_system_config: Optional['outputs.AppImageConfigKernelGatewayImageConfigFileSystemConfig'] = None):
        """
        :param 'AppImageConfigKernelGatewayImageConfigKernelSpecArgs' kernel_spec: The default branch for the Git repository. See Kernel Spec details below.
        :param '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) -> 'outputs.AppImageConfigKernelGatewayImageConfigKernelSpec':
        """
        The default branch for the Git repository. See Kernel Spec details below.
        """
        return pulumi.get(self, "kernel_spec")

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


@pulumi.output_type
class AppImageConfigKernelGatewayImageConfigFileSystemConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultGid":
            suggest = "default_gid"
        elif key == "defaultUid":
            suggest = "default_uid"
        elif key == "mountPath":
            suggest = "mount_path"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AppImageConfigKernelGatewayImageConfigFileSystemConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AppImageConfigKernelGatewayImageConfigFileSystemConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AppImageConfigKernelGatewayImageConfigFileSystemConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 default_gid: Optional[int] = None,
                 default_uid: Optional[int] = None,
                 mount_path: Optional[str] = None):
        """
        :param int default_gid: The default POSIX group ID (GID). If not specified, defaults to `100`. Valid values are `0` and `100`.
        :param int default_uid: The default POSIX user ID (UID). If not specified, defaults to `1000`. Valid values are `0` and `1000`.
        :param 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[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")

    @property
    @pulumi.getter(name="defaultUid")
    def default_uid(self) -> Optional[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")

    @property
    @pulumi.getter(name="mountPath")
    def mount_path(self) -> Optional[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")


@pulumi.output_type
class AppImageConfigKernelGatewayImageConfigKernelSpec(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "displayName":
            suggest = "display_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AppImageConfigKernelGatewayImageConfigKernelSpec. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AppImageConfigKernelGatewayImageConfigKernelSpec.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AppImageConfigKernelGatewayImageConfigKernelSpec.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: str,
                 display_name: Optional[str] = None):
        """
        :param str name: The name of the kernel.
        :param 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) -> str:
        """
        The name of the kernel.
        """
        return pulumi.get(self, "name")

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


@pulumi.output_type
class AppResourceSpec(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instanceType":
            suggest = "instance_type"
        elif key == "lifecycleConfigArn":
            suggest = "lifecycle_config_arn"
        elif key == "sagemakerImageArn":
            suggest = "sagemaker_image_arn"
        elif key == "sagemakerImageVersionArn":
            suggest = "sagemaker_image_version_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AppResourceSpec. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AppResourceSpec.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AppResourceSpec.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 instance_type: Optional[str] = None,
                 lifecycle_config_arn: Optional[str] = None,
                 sagemaker_image_arn: Optional[str] = None,
                 sagemaker_image_version_arn: Optional[str] = None):
        """
        :param 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 str lifecycle_config_arn: The Amazon Resource Name (ARN) of the Lifecycle Configuration attached to the Resource.
        :param str sagemaker_image_arn: The ARN of the SageMaker image that the image version belongs to.
        :param str sagemaker_image_version_arn: The ARN of the image version created on the instance.
        """
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if lifecycle_config_arn is not None:
            pulumi.set(__self__, "lifecycle_config_arn", lifecycle_config_arn)
        if sagemaker_image_arn is not None:
            pulumi.set(__self__, "sagemaker_image_arn", sagemaker_image_arn)
        if sagemaker_image_version_arn is not None:
            pulumi.set(__self__, "sagemaker_image_version_arn", sagemaker_image_version_arn)

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[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")

    @property
    @pulumi.getter(name="lifecycleConfigArn")
    def lifecycle_config_arn(self) -> Optional[str]:
        """
        The Amazon Resource Name (ARN) of the Lifecycle Configuration attached to the Resource.
        """
        return pulumi.get(self, "lifecycle_config_arn")

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

    @property
    @pulumi.getter(name="sagemakerImageVersionArn")
    def sagemaker_image_version_arn(self) -> Optional[str]:
        """
        The ARN of the image version created on the instance.
        """
        return pulumi.get(self, "sagemaker_image_version_arn")


@pulumi.output_type
class CodeRepositoryGitConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "repositoryUrl":
            suggest = "repository_url"
        elif key == "secretArn":
            suggest = "secret_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CodeRepositoryGitConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CodeRepositoryGitConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CodeRepositoryGitConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 repository_url: str,
                 branch: Optional[str] = None,
                 secret_arn: Optional[str] = None):
        """
        :param str repository_url: The URL where the Git repository is located.
        :param str branch: The default branch for the Git repository.
        :param 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) -> str:
        """
        The URL where the Git repository is located.
        """
        return pulumi.get(self, "repository_url")

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

    @property
    @pulumi.getter(name="secretArn")
    def secret_arn(self) -> Optional[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")


@pulumi.output_type
class DeviceDevice(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deviceName":
            suggest = "device_name"
        elif key == "iotThingName":
            suggest = "iot_thing_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeviceDevice. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeviceDevice.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeviceDevice.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 device_name: str,
                 description: Optional[str] = None,
                 iot_thing_name: Optional[str] = None):
        """
        :param str device_name: The name of the device.
        :param str description: A description for the device.
        :param str iot_thing_name: Amazon Web Services Internet of Things (IoT) object name.
        """
        pulumi.set(__self__, "device_name", device_name)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if iot_thing_name is not None:
            pulumi.set(__self__, "iot_thing_name", iot_thing_name)

    @property
    @pulumi.getter(name="deviceName")
    def device_name(self) -> str:
        """
        The name of the device.
        """
        return pulumi.get(self, "device_name")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        A description for the device.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="iotThingName")
    def iot_thing_name(self) -> Optional[str]:
        """
        Amazon Web Services Internet of Things (IoT) object name.
        """
        return pulumi.get(self, "iot_thing_name")


@pulumi.output_type
class DeviceFleetOutputConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "s3OutputLocation":
            suggest = "s3_output_location"
        elif key == "kmsKeyId":
            suggest = "kms_key_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeviceFleetOutputConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeviceFleetOutputConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeviceFleetOutputConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 s3_output_location: str,
                 kms_key_id: Optional[str] = None):
        """
        :param str s3_output_location: The Amazon Simple Storage (S3) bucker URI.
        :param 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) -> str:
        """
        The Amazon Simple Storage (S3) bucker URI.
        """
        return pulumi.get(self, "s3_output_location")

    @property
    @pulumi.getter(name="kmsKeyId")
    def kms_key_id(self) -> Optional[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")


@pulumi.output_type
class DomainDefaultUserSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "executionRole":
            suggest = "execution_role"
        elif key == "jupyterServerAppSettings":
            suggest = "jupyter_server_app_settings"
        elif key == "kernelGatewayAppSettings":
            suggest = "kernel_gateway_app_settings"
        elif key == "securityGroups":
            suggest = "security_groups"
        elif key == "sharingSettings":
            suggest = "sharing_settings"
        elif key == "tensorBoardAppSettings":
            suggest = "tensor_board_app_settings"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DomainDefaultUserSettings. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DomainDefaultUserSettings.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DomainDefaultUserSettings.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 execution_role: str,
                 jupyter_server_app_settings: Optional['outputs.DomainDefaultUserSettingsJupyterServerAppSettings'] = None,
                 kernel_gateway_app_settings: Optional['outputs.DomainDefaultUserSettingsKernelGatewayAppSettings'] = None,
                 security_groups: Optional[Sequence[str]] = None,
                 sharing_settings: Optional['outputs.DomainDefaultUserSettingsSharingSettings'] = None,
                 tensor_board_app_settings: Optional['outputs.DomainDefaultUserSettingsTensorBoardAppSettings'] = None):
        """
        :param str execution_role: The execution role ARN for the user.
        :param 'DomainDefaultUserSettingsJupyterServerAppSettingsArgs' jupyter_server_app_settings: The Jupyter server's app settings. See Jupyter Server App Settings below.
        :param 'DomainDefaultUserSettingsKernelGatewayAppSettingsArgs' kernel_gateway_app_settings: The kernel gateway app settings. See Kernel Gateway App Settings below.
        :param Sequence[str] security_groups: The security groups.
        :param 'DomainDefaultUserSettingsSharingSettingsArgs' sharing_settings: The sharing settings. See Sharing Settings below.
        :param '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) -> str:
        """
        The execution role ARN for the user.
        """
        return pulumi.get(self, "execution_role")

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

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

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

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

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


@pulumi.output_type
class DomainDefaultUserSettingsJupyterServerAppSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultResourceSpec":
            suggest = "default_resource_spec"
        elif key == "lifecycleConfigArns":
            suggest = "lifecycle_config_arns"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DomainDefaultUserSettingsJupyterServerAppSettings. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DomainDefaultUserSettingsJupyterServerAppSettings.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DomainDefaultUserSettingsJupyterServerAppSettings.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 default_resource_spec: Optional['outputs.DomainDefaultUserSettingsJupyterServerAppSettingsDefaultResourceSpec'] = None,
                 lifecycle_config_arns: Optional[Sequence[str]] = None):
        """
        :param '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 Sequence[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['outputs.DomainDefaultUserSettingsJupyterServerAppSettingsDefaultResourceSpec']:
        """
        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")

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


@pulumi.output_type
class DomainDefaultUserSettingsJupyterServerAppSettingsDefaultResourceSpec(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instanceType":
            suggest = "instance_type"
        elif key == "lifecycleConfigArn":
            suggest = "lifecycle_config_arn"
        elif key == "sagemakerImageArn":
            suggest = "sagemaker_image_arn"
        elif key == "sagemakerImageVersionArn":
            suggest = "sagemaker_image_version_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DomainDefaultUserSettingsJupyterServerAppSettingsDefaultResourceSpec. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DomainDefaultUserSettingsJupyterServerAppSettingsDefaultResourceSpec.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DomainDefaultUserSettingsJupyterServerAppSettingsDefaultResourceSpec.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 instance_type: Optional[str] = None,
                 lifecycle_config_arn: Optional[str] = None,
                 sagemaker_image_arn: Optional[str] = None,
                 sagemaker_image_version_arn: Optional[str] = None):
        """
        :param 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 str lifecycle_config_arn: The Amazon Resource Name (ARN) of the Lifecycle Configuration attached to the Resource.
        :param str sagemaker_image_arn: The ARN of the SageMaker image that the image version belongs to.
        :param str sagemaker_image_version_arn: The ARN of the image version created on the instance.
        """
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if lifecycle_config_arn is not None:
            pulumi.set(__self__, "lifecycle_config_arn", lifecycle_config_arn)
        if sagemaker_image_arn is not None:
            pulumi.set(__self__, "sagemaker_image_arn", sagemaker_image_arn)
        if sagemaker_image_version_arn is not None:
            pulumi.set(__self__, "sagemaker_image_version_arn", sagemaker_image_version_arn)

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[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")

    @property
    @pulumi.getter(name="lifecycleConfigArn")
    def lifecycle_config_arn(self) -> Optional[str]:
        """
        The Amazon Resource Name (ARN) of the Lifecycle Configuration attached to the Resource.
        """
        return pulumi.get(self, "lifecycle_config_arn")

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

    @property
    @pulumi.getter(name="sagemakerImageVersionArn")
    def sagemaker_image_version_arn(self) -> Optional[str]:
        """
        The ARN of the image version created on the instance.
        """
        return pulumi.get(self, "sagemaker_image_version_arn")


@pulumi.output_type
class DomainDefaultUserSettingsKernelGatewayAppSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "customImages":
            suggest = "custom_images"
        elif key == "defaultResourceSpec":
            suggest = "default_resource_spec"
        elif key == "lifecycleConfigArns":
            suggest = "lifecycle_config_arns"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DomainDefaultUserSettingsKernelGatewayAppSettings. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DomainDefaultUserSettingsKernelGatewayAppSettings.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DomainDefaultUserSettingsKernelGatewayAppSettings.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 custom_images: Optional[Sequence['outputs.DomainDefaultUserSettingsKernelGatewayAppSettingsCustomImage']] = None,
                 default_resource_spec: Optional['outputs.DomainDefaultUserSettingsKernelGatewayAppSettingsDefaultResourceSpec'] = None,
                 lifecycle_config_arns: Optional[Sequence[str]] = None):
        """
        :param Sequence['DomainDefaultUserSettingsKernelGatewayAppSettingsCustomImageArgs'] custom_images: A list of custom SageMaker images that are configured to run as a KernelGateway app. see Custom Image below.
        :param '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 Sequence[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[Sequence['outputs.DomainDefaultUserSettingsKernelGatewayAppSettingsCustomImage']]:
        """
        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")

    @property
    @pulumi.getter(name="defaultResourceSpec")
    def default_resource_spec(self) -> Optional['outputs.DomainDefaultUserSettingsKernelGatewayAppSettingsDefaultResourceSpec']:
        """
        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")

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


@pulumi.output_type
class DomainDefaultUserSettingsKernelGatewayAppSettingsCustomImage(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "appImageConfigName":
            suggest = "app_image_config_name"
        elif key == "imageName":
            suggest = "image_name"
        elif key == "imageVersionNumber":
            suggest = "image_version_number"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DomainDefaultUserSettingsKernelGatewayAppSettingsCustomImage. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DomainDefaultUserSettingsKernelGatewayAppSettingsCustomImage.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DomainDefaultUserSettingsKernelGatewayAppSettingsCustomImage.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 app_image_config_name: str,
                 image_name: str,
                 image_version_number: Optional[int] = None):
        """
        :param str app_image_config_name: The name of the App Image Config.
        :param str image_name: The name of the Custom Image.
        :param 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) -> str:
        """
        The name of the App Image Config.
        """
        return pulumi.get(self, "app_image_config_name")

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

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


@pulumi.output_type
class DomainDefaultUserSettingsKernelGatewayAppSettingsDefaultResourceSpec(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instanceType":
            suggest = "instance_type"
        elif key == "lifecycleConfigArn":
            suggest = "lifecycle_config_arn"
        elif key == "sagemakerImageArn":
            suggest = "sagemaker_image_arn"
        elif key == "sagemakerImageVersionArn":
            suggest = "sagemaker_image_version_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DomainDefaultUserSettingsKernelGatewayAppSettingsDefaultResourceSpec. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DomainDefaultUserSettingsKernelGatewayAppSettingsDefaultResourceSpec.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DomainDefaultUserSettingsKernelGatewayAppSettingsDefaultResourceSpec.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 instance_type: Optional[str] = None,
                 lifecycle_config_arn: Optional[str] = None,
                 sagemaker_image_arn: Optional[str] = None,
                 sagemaker_image_version_arn: Optional[str] = None):
        """
        :param 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 str lifecycle_config_arn: The Amazon Resource Name (ARN) of the Lifecycle Configuration attached to the Resource.
        :param str sagemaker_image_arn: The ARN of the SageMaker image that the image version belongs to.
        :param str sagemaker_image_version_arn: The ARN of the image version created on the instance.
        """
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if lifecycle_config_arn is not None:
            pulumi.set(__self__, "lifecycle_config_arn", lifecycle_config_arn)
        if sagemaker_image_arn is not None:
            pulumi.set(__self__, "sagemaker_image_arn", sagemaker_image_arn)
        if sagemaker_image_version_arn is not None:
            pulumi.set(__self__, "sagemaker_image_version_arn", sagemaker_image_version_arn)

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[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")

    @property
    @pulumi.getter(name="lifecycleConfigArn")
    def lifecycle_config_arn(self) -> Optional[str]:
        """
        The Amazon Resource Name (ARN) of the Lifecycle Configuration attached to the Resource.
        """
        return pulumi.get(self, "lifecycle_config_arn")

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

    @property
    @pulumi.getter(name="sagemakerImageVersionArn")
    def sagemaker_image_version_arn(self) -> Optional[str]:
        """
        The ARN of the image version created on the instance.
        """
        return pulumi.get(self, "sagemaker_image_version_arn")


@pulumi.output_type
class DomainDefaultUserSettingsSharingSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "notebookOutputOption":
            suggest = "notebook_output_option"
        elif key == "s3KmsKeyId":
            suggest = "s3_kms_key_id"
        elif key == "s3OutputPath":
            suggest = "s3_output_path"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DomainDefaultUserSettingsSharingSettings. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DomainDefaultUserSettingsSharingSettings.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DomainDefaultUserSettingsSharingSettings.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 notebook_output_option: Optional[str] = None,
                 s3_kms_key_id: Optional[str] = None,
                 s3_output_path: Optional[str] = None):
        """
        :param 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 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 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[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")

    @property
    @pulumi.getter(name="s3KmsKeyId")
    def s3_kms_key_id(self) -> Optional[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")

    @property
    @pulumi.getter(name="s3OutputPath")
    def s3_output_path(self) -> Optional[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")


@pulumi.output_type
class DomainDefaultUserSettingsTensorBoardAppSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultResourceSpec":
            suggest = "default_resource_spec"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DomainDefaultUserSettingsTensorBoardAppSettings. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DomainDefaultUserSettingsTensorBoardAppSettings.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DomainDefaultUserSettingsTensorBoardAppSettings.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 default_resource_spec: Optional['outputs.DomainDefaultUserSettingsTensorBoardAppSettingsDefaultResourceSpec'] = None):
        """
        :param '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['outputs.DomainDefaultUserSettingsTensorBoardAppSettingsDefaultResourceSpec']:
        """
        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")


@pulumi.output_type
class DomainDefaultUserSettingsTensorBoardAppSettingsDefaultResourceSpec(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instanceType":
            suggest = "instance_type"
        elif key == "lifecycleConfigArn":
            suggest = "lifecycle_config_arn"
        elif key == "sagemakerImageArn":
            suggest = "sagemaker_image_arn"
        elif key == "sagemakerImageVersionArn":
            suggest = "sagemaker_image_version_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DomainDefaultUserSettingsTensorBoardAppSettingsDefaultResourceSpec. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DomainDefaultUserSettingsTensorBoardAppSettingsDefaultResourceSpec.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DomainDefaultUserSettingsTensorBoardAppSettingsDefaultResourceSpec.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 instance_type: Optional[str] = None,
                 lifecycle_config_arn: Optional[str] = None,
                 sagemaker_image_arn: Optional[str] = None,
                 sagemaker_image_version_arn: Optional[str] = None):
        """
        :param 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 str lifecycle_config_arn: The Amazon Resource Name (ARN) of the Lifecycle Configuration attached to the Resource.
        :param str sagemaker_image_arn: The ARN of the SageMaker image that the image version belongs to.
        :param str sagemaker_image_version_arn: The ARN of the image version created on the instance.
        """
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if lifecycle_config_arn is not None:
            pulumi.set(__self__, "lifecycle_config_arn", lifecycle_config_arn)
        if sagemaker_image_arn is not None:
            pulumi.set(__self__, "sagemaker_image_arn", sagemaker_image_arn)
        if sagemaker_image_version_arn is not None:
            pulumi.set(__self__, "sagemaker_image_version_arn", sagemaker_image_version_arn)

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[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")

    @property
    @pulumi.getter(name="lifecycleConfigArn")
    def lifecycle_config_arn(self) -> Optional[str]:
        """
        The Amazon Resource Name (ARN) of the Lifecycle Configuration attached to the Resource.
        """
        return pulumi.get(self, "lifecycle_config_arn")

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

    @property
    @pulumi.getter(name="sagemakerImageVersionArn")
    def sagemaker_image_version_arn(self) -> Optional[str]:
        """
        The ARN of the image version created on the instance.
        """
        return pulumi.get(self, "sagemaker_image_version_arn")


@pulumi.output_type
class DomainRetentionPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "homeEfsFileSystem":
            suggest = "home_efs_file_system"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DomainRetentionPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DomainRetentionPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DomainRetentionPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 home_efs_file_system: Optional[str] = None):
        """
        :param str home_efs_file_system: The retention policy for data stored on an Amazon Elastic File System (EFS) volume. Valid values are `Retain` or `Delete`.  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[str]:
        """
        The retention policy for data stored on an Amazon Elastic File System (EFS) volume. Valid values are `Retain` or `Delete`.  Default value is `Retain`.
        """
        return pulumi.get(self, "home_efs_file_system")


@pulumi.output_type
class EndpointConfigurationAsyncInferenceConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "outputConfig":
            suggest = "output_config"
        elif key == "clientConfig":
            suggest = "client_config"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EndpointConfigurationAsyncInferenceConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EndpointConfigurationAsyncInferenceConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EndpointConfigurationAsyncInferenceConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 output_config: 'outputs.EndpointConfigurationAsyncInferenceConfigOutputConfig',
                 client_config: Optional['outputs.EndpointConfigurationAsyncInferenceConfigClientConfig'] = None):
        """
        :param 'EndpointConfigurationAsyncInferenceConfigOutputConfigArgs' output_config: Specifies the configuration for asynchronous inference invocation outputs.
        :param '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) -> 'outputs.EndpointConfigurationAsyncInferenceConfigOutputConfig':
        """
        Specifies the configuration for asynchronous inference invocation outputs.
        """
        return pulumi.get(self, "output_config")

    @property
    @pulumi.getter(name="clientConfig")
    def client_config(self) -> Optional['outputs.EndpointConfigurationAsyncInferenceConfigClientConfig']:
        """
        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")


@pulumi.output_type
class EndpointConfigurationAsyncInferenceConfigClientConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxConcurrentInvocationsPerInstance":
            suggest = "max_concurrent_invocations_per_instance"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EndpointConfigurationAsyncInferenceConfigClientConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EndpointConfigurationAsyncInferenceConfigClientConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EndpointConfigurationAsyncInferenceConfigClientConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 max_concurrent_invocations_per_instance: Optional[int] = None):
        """
        :param 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[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")


@pulumi.output_type
class EndpointConfigurationAsyncInferenceConfigOutputConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "s3OutputPath":
            suggest = "s3_output_path"
        elif key == "kmsKeyId":
            suggest = "kms_key_id"
        elif key == "notificationConfig":
            suggest = "notification_config"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EndpointConfigurationAsyncInferenceConfigOutputConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EndpointConfigurationAsyncInferenceConfigOutputConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EndpointConfigurationAsyncInferenceConfigOutputConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 s3_output_path: str,
                 kms_key_id: Optional[str] = None,
                 notification_config: Optional['outputs.EndpointConfigurationAsyncInferenceConfigOutputConfigNotificationConfig'] = None):
        """
        :param str s3_output_path: The Amazon S3 location to upload inference responses to.
        :param 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 '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) -> str:
        """
        The Amazon S3 location to upload inference responses to.
        """
        return pulumi.get(self, "s3_output_path")

    @property
    @pulumi.getter(name="kmsKeyId")
    def kms_key_id(self) -> Optional[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")

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


@pulumi.output_type
class EndpointConfigurationAsyncInferenceConfigOutputConfigNotificationConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "errorTopic":
            suggest = "error_topic"
        elif key == "successTopic":
            suggest = "success_topic"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EndpointConfigurationAsyncInferenceConfigOutputConfigNotificationConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EndpointConfigurationAsyncInferenceConfigOutputConfigNotificationConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EndpointConfigurationAsyncInferenceConfigOutputConfigNotificationConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 error_topic: Optional[str] = None,
                 success_topic: Optional[str] = None):
        """
        :param 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 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[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")

    @property
    @pulumi.getter(name="successTopic")
    def success_topic(self) -> Optional[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")


@pulumi.output_type
class EndpointConfigurationDataCaptureConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "captureOptions":
            suggest = "capture_options"
        elif key == "destinationS3Uri":
            suggest = "destination_s3_uri"
        elif key == "initialSamplingPercentage":
            suggest = "initial_sampling_percentage"
        elif key == "captureContentTypeHeader":
            suggest = "capture_content_type_header"
        elif key == "enableCapture":
            suggest = "enable_capture"
        elif key == "kmsKeyId":
            suggest = "kms_key_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EndpointConfigurationDataCaptureConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EndpointConfigurationDataCaptureConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EndpointConfigurationDataCaptureConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 capture_options: Sequence['outputs.EndpointConfigurationDataCaptureConfigCaptureOption'],
                 destination_s3_uri: str,
                 initial_sampling_percentage: int,
                 capture_content_type_header: Optional['outputs.EndpointConfigurationDataCaptureConfigCaptureContentTypeHeader'] = None,
                 enable_capture: Optional[bool] = None,
                 kms_key_id: Optional[str] = None):
        """
        :param Sequence['EndpointConfigurationDataCaptureConfigCaptureOptionArgs'] capture_options: Specifies what data to capture. Fields are documented below.
        :param str destination_s3_uri: The URL for S3 location where the captured data is stored.
        :param int initial_sampling_percentage: Portion of data to capture. Should be between 0 and 100.
        :param 'EndpointConfigurationDataCaptureConfigCaptureContentTypeHeaderArgs' capture_content_type_header: The content type headers to capture. Fields are documented below.
        :param bool enable_capture: Flag to enable data capture. Defaults to `false`.
        :param 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) -> Sequence['outputs.EndpointConfigurationDataCaptureConfigCaptureOption']:
        """
        Specifies what data to capture. Fields are documented below.
        """
        return pulumi.get(self, "capture_options")

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

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

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

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

    @property
    @pulumi.getter(name="kmsKeyId")
    def kms_key_id(self) -> Optional[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")


@pulumi.output_type
class EndpointConfigurationDataCaptureConfigCaptureContentTypeHeader(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "csvContentTypes":
            suggest = "csv_content_types"
        elif key == "jsonContentTypes":
            suggest = "json_content_types"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EndpointConfigurationDataCaptureConfigCaptureContentTypeHeader. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EndpointConfigurationDataCaptureConfigCaptureContentTypeHeader.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EndpointConfigurationDataCaptureConfigCaptureContentTypeHeader.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 csv_content_types: Optional[Sequence[str]] = None,
                 json_content_types: Optional[Sequence[str]] = None):
        """
        :param Sequence[str] csv_content_types: The CSV content type headers to capture.
        :param Sequence[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[Sequence[str]]:
        """
        The CSV content type headers to capture.
        """
        return pulumi.get(self, "csv_content_types")

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


@pulumi.output_type
class EndpointConfigurationDataCaptureConfigCaptureOption(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "captureMode":
            suggest = "capture_mode"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EndpointConfigurationDataCaptureConfigCaptureOption. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EndpointConfigurationDataCaptureConfigCaptureOption.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EndpointConfigurationDataCaptureConfigCaptureOption.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 capture_mode: str):
        """
        :param 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) -> str:
        """
        Specifies the data to be captured. Should be one of `Input` or `Output`.
        """
        return pulumi.get(self, "capture_mode")


@pulumi.output_type
class EndpointConfigurationProductionVariant(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "initialInstanceCount":
            suggest = "initial_instance_count"
        elif key == "instanceType":
            suggest = "instance_type"
        elif key == "modelName":
            suggest = "model_name"
        elif key == "acceleratorType":
            suggest = "accelerator_type"
        elif key == "initialVariantWeight":
            suggest = "initial_variant_weight"
        elif key == "variantName":
            suggest = "variant_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EndpointConfigurationProductionVariant. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EndpointConfigurationProductionVariant.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EndpointConfigurationProductionVariant.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 initial_instance_count: int,
                 instance_type: str,
                 model_name: str,
                 accelerator_type: Optional[str] = None,
                 initial_variant_weight: Optional[float] = None,
                 variant_name: Optional[str] = None):
        """
        :param int initial_instance_count: Initial number of instances used for auto-scaling.
        :param str instance_type: The type of instance to start.
        :param str model_name: The name of the model to use.
        :param str accelerator_type: The size of the Elastic Inference (EI) instance to use for the production variant.
        :param 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 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) -> int:
        """
        Initial number of instances used for auto-scaling.
        """
        return pulumi.get(self, "initial_instance_count")

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

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

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

    @property
    @pulumi.getter(name="initialVariantWeight")
    def initial_variant_weight(self) -> Optional[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")

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


@pulumi.output_type
class EndpointDeploymentConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "blueGreenUpdatePolicy":
            suggest = "blue_green_update_policy"
        elif key == "autoRollbackConfiguration":
            suggest = "auto_rollback_configuration"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EndpointDeploymentConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EndpointDeploymentConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EndpointDeploymentConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 blue_green_update_policy: 'outputs.EndpointDeploymentConfigBlueGreenUpdatePolicy',
                 auto_rollback_configuration: Optional['outputs.EndpointDeploymentConfigAutoRollbackConfiguration'] = None):
        """
        :param '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 '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) -> 'outputs.EndpointDeploymentConfigBlueGreenUpdatePolicy':
        """
        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")

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


@pulumi.output_type
class EndpointDeploymentConfigAutoRollbackConfiguration(dict):
    def __init__(__self__, *,
                 alarms: Optional[Sequence['outputs.EndpointDeploymentConfigAutoRollbackConfigurationAlarm']] = None):
        """
        :param Sequence['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[Sequence['outputs.EndpointDeploymentConfigAutoRollbackConfigurationAlarm']]:
        """
        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")


@pulumi.output_type
class EndpointDeploymentConfigAutoRollbackConfigurationAlarm(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "alarmName":
            suggest = "alarm_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EndpointDeploymentConfigAutoRollbackConfigurationAlarm. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EndpointDeploymentConfigAutoRollbackConfigurationAlarm.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EndpointDeploymentConfigAutoRollbackConfigurationAlarm.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 alarm_name: str):
        """
        :param 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) -> str:
        """
        The name of a CloudWatch alarm in your account.
        """
        return pulumi.get(self, "alarm_name")


@pulumi.output_type
class EndpointDeploymentConfigBlueGreenUpdatePolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "trafficRoutingConfiguration":
            suggest = "traffic_routing_configuration"
        elif key == "maximumExecutionTimeoutInSeconds":
            suggest = "maximum_execution_timeout_in_seconds"
        elif key == "terminationWaitInSeconds":
            suggest = "termination_wait_in_seconds"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EndpointDeploymentConfigBlueGreenUpdatePolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EndpointDeploymentConfigBlueGreenUpdatePolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EndpointDeploymentConfigBlueGreenUpdatePolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 traffic_routing_configuration: 'outputs.EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfiguration',
                 maximum_execution_timeout_in_seconds: Optional[int] = None,
                 termination_wait_in_seconds: Optional[int] = None):
        """
        :param '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 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 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) -> 'outputs.EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfiguration':
        """
        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")

    @property
    @pulumi.getter(name="maximumExecutionTimeoutInSeconds")
    def maximum_execution_timeout_in_seconds(self) -> Optional[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")

    @property
    @pulumi.getter(name="terminationWaitInSeconds")
    def termination_wait_in_seconds(self) -> Optional[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")


@pulumi.output_type
class EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "waitIntervalInSeconds":
            suggest = "wait_interval_in_seconds"
        elif key == "canarySize":
            suggest = "canary_size"
        elif key == "linearStepSize":
            suggest = "linear_step_size"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 type: str,
                 wait_interval_in_seconds: int,
                 canary_size: Optional['outputs.EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfigurationCanarySize'] = None,
                 linear_step_size: Optional['outputs.EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfigurationLinearStepSize'] = None):
        """
        :param str type: Specifies the endpoint capacity type. Valid values are: `INSTANCE_COUNT`, or `CAPACITY_PERCENT`.
        :param 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 '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 '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) -> str:
        """
        Specifies the endpoint capacity type. Valid values are: `INSTANCE_COUNT`, or `CAPACITY_PERCENT`.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="waitIntervalInSeconds")
    def wait_interval_in_seconds(self) -> 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")

    @property
    @pulumi.getter(name="canarySize")
    def canary_size(self) -> Optional['outputs.EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfigurationCanarySize']:
        """
        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")

    @property
    @pulumi.getter(name="linearStepSize")
    def linear_step_size(self) -> Optional['outputs.EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfigurationLinearStepSize']:
        """
        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")


@pulumi.output_type
class EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfigurationCanarySize(dict):
    def __init__(__self__, *,
                 type: str,
                 value: int):
        """
        :param str type: Specifies the endpoint capacity type. Valid values are: `INSTANCE_COUNT`, or `CAPACITY_PERCENT`.
        :param 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) -> str:
        """
        Specifies the endpoint capacity type. Valid values are: `INSTANCE_COUNT`, or `CAPACITY_PERCENT`.
        """
        return pulumi.get(self, "type")

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


@pulumi.output_type
class EndpointDeploymentConfigBlueGreenUpdatePolicyTrafficRoutingConfigurationLinearStepSize(dict):
    def __init__(__self__, *,
                 type: str,
                 value: int):
        """
        :param str type: Specifies the endpoint capacity type. Valid values are: `INSTANCE_COUNT`, or `CAPACITY_PERCENT`.
        :param 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) -> str:
        """
        Specifies the endpoint capacity type. Valid values are: `INSTANCE_COUNT`, or `CAPACITY_PERCENT`.
        """
        return pulumi.get(self, "type")

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


@pulumi.output_type
class FeatureGroupFeatureDefinition(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "featureName":
            suggest = "feature_name"
        elif key == "featureType":
            suggest = "feature_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in FeatureGroupFeatureDefinition. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        FeatureGroupFeatureDefinition.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        FeatureGroupFeatureDefinition.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 feature_name: Optional[str] = None,
                 feature_type: Optional[str] = None):
        """
        :param str feature_name: The name of a feature. `feature_name` cannot be any of the following: `is_deleted`, `write_time`, `api_invocation_time`.
        :param 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[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")

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


@pulumi.output_type
class FeatureGroupOfflineStoreConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "s3StorageConfig":
            suggest = "s3_storage_config"
        elif key == "dataCatalogConfig":
            suggest = "data_catalog_config"
        elif key == "disableGlueTableCreation":
            suggest = "disable_glue_table_creation"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in FeatureGroupOfflineStoreConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        FeatureGroupOfflineStoreConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        FeatureGroupOfflineStoreConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 s3_storage_config: 'outputs.FeatureGroupOfflineStoreConfigS3StorageConfig',
                 data_catalog_config: Optional['outputs.FeatureGroupOfflineStoreConfigDataCatalogConfig'] = None,
                 disable_glue_table_creation: Optional[bool] = None):
        """
        :param 'FeatureGroupOfflineStoreConfigS3StorageConfigArgs' s3_storage_config: The Amazon Simple Storage (Amazon S3) location of OfflineStore. See S3 Storage Config Below.
        :param '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 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) -> 'outputs.FeatureGroupOfflineStoreConfigS3StorageConfig':
        """
        The Amazon Simple Storage (Amazon S3) location of OfflineStore. See S3 Storage Config Below.
        """
        return pulumi.get(self, "s3_storage_config")

    @property
    @pulumi.getter(name="dataCatalogConfig")
    def data_catalog_config(self) -> Optional['outputs.FeatureGroupOfflineStoreConfigDataCatalogConfig']:
        """
        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")

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


@pulumi.output_type
class FeatureGroupOfflineStoreConfigDataCatalogConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "tableName":
            suggest = "table_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in FeatureGroupOfflineStoreConfigDataCatalogConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        FeatureGroupOfflineStoreConfigDataCatalogConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        FeatureGroupOfflineStoreConfigDataCatalogConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 catalog: Optional[str] = None,
                 database: Optional[str] = None,
                 table_name: Optional[str] = None):
        """
        :param str catalog: The name of the Glue table catalog.
        :param str database: The name of the Glue table database.
        :param 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[str]:
        """
        The name of the Glue table catalog.
        """
        return pulumi.get(self, "catalog")

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

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


@pulumi.output_type
class FeatureGroupOfflineStoreConfigS3StorageConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "s3Uri":
            suggest = "s3_uri"
        elif key == "kmsKeyId":
            suggest = "kms_key_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in FeatureGroupOfflineStoreConfigS3StorageConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        FeatureGroupOfflineStoreConfigS3StorageConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        FeatureGroupOfflineStoreConfigS3StorageConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 s3_uri: str,
                 kms_key_id: Optional[str] = None):
        """
        :param str s3_uri: The S3 URI, or location in Amazon S3, of OfflineStore.
        :param 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) -> str:
        """
        The S3 URI, or location in Amazon S3, of OfflineStore.
        """
        return pulumi.get(self, "s3_uri")

    @property
    @pulumi.getter(name="kmsKeyId")
    def kms_key_id(self) -> Optional[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")


@pulumi.output_type
class FeatureGroupOnlineStoreConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enableOnlineStore":
            suggest = "enable_online_store"
        elif key == "securityConfig":
            suggest = "security_config"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in FeatureGroupOnlineStoreConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        FeatureGroupOnlineStoreConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        FeatureGroupOnlineStoreConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enable_online_store: Optional[bool] = None,
                 security_config: Optional['outputs.FeatureGroupOnlineStoreConfigSecurityConfig'] = None):
        """
        :param bool enable_online_store: Set to `true` to disable the automatic creation of an AWS Glue table when configuring an OfflineStore.
        :param '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[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")

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


@pulumi.output_type
class FeatureGroupOnlineStoreConfigSecurityConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kmsKeyId":
            suggest = "kms_key_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in FeatureGroupOnlineStoreConfigSecurityConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        FeatureGroupOnlineStoreConfigSecurityConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        FeatureGroupOnlineStoreConfigSecurityConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kms_key_id: Optional[str] = None):
        """
        :param 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[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")


@pulumi.output_type
class FlowDefinitionHumanLoopActivationConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "humanLoopActivationConditionsConfig":
            suggest = "human_loop_activation_conditions_config"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in FlowDefinitionHumanLoopActivationConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        FlowDefinitionHumanLoopActivationConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        FlowDefinitionHumanLoopActivationConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 human_loop_activation_conditions_config: Optional['outputs.FlowDefinitionHumanLoopActivationConfigHumanLoopActivationConditionsConfig'] = None):
        """
        :param '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['outputs.FlowDefinitionHumanLoopActivationConfigHumanLoopActivationConditionsConfig']:
        """
        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")


@pulumi.output_type
class FlowDefinitionHumanLoopActivationConfigHumanLoopActivationConditionsConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "humanLoopActivationConditions":
            suggest = "human_loop_activation_conditions"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in FlowDefinitionHumanLoopActivationConfigHumanLoopActivationConditionsConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        FlowDefinitionHumanLoopActivationConfigHumanLoopActivationConditionsConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        FlowDefinitionHumanLoopActivationConfigHumanLoopActivationConditionsConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 human_loop_activation_conditions: str):
        """
        :param 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) -> 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")


@pulumi.output_type
class FlowDefinitionHumanLoopConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "humanTaskUiArn":
            suggest = "human_task_ui_arn"
        elif key == "taskCount":
            suggest = "task_count"
        elif key == "taskDescription":
            suggest = "task_description"
        elif key == "taskTitle":
            suggest = "task_title"
        elif key == "workteamArn":
            suggest = "workteam_arn"
        elif key == "publicWorkforceTaskPrice":
            suggest = "public_workforce_task_price"
        elif key == "taskAvailabilityLifetimeInSeconds":
            suggest = "task_availability_lifetime_in_seconds"
        elif key == "taskKeywords":
            suggest = "task_keywords"
        elif key == "taskTimeLimitInSeconds":
            suggest = "task_time_limit_in_seconds"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in FlowDefinitionHumanLoopConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        FlowDefinitionHumanLoopConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        FlowDefinitionHumanLoopConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 human_task_ui_arn: str,
                 task_count: int,
                 task_description: str,
                 task_title: str,
                 workteam_arn: str,
                 public_workforce_task_price: Optional['outputs.FlowDefinitionHumanLoopConfigPublicWorkforceTaskPrice'] = None,
                 task_availability_lifetime_in_seconds: Optional[int] = None,
                 task_keywords: Optional[Sequence[str]] = None,
                 task_time_limit_in_seconds: Optional[int] = None):
        """
        :param str human_task_ui_arn: The Amazon Resource Name (ARN) of the human task user interface.
        :param 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 str task_description: A description for the human worker task.
        :param str task_title: A title for the human worker task.
        :param 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 '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 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 Sequence[str] task_keywords: An array of keywords used to describe the task so that workers can discover the task.
        :param 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) -> str:
        """
        The Amazon Resource Name (ARN) of the human task user interface.
        """
        return pulumi.get(self, "human_task_ui_arn")

    @property
    @pulumi.getter(name="taskCount")
    def task_count(self) -> 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")

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

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

    @property
    @pulumi.getter(name="workteamArn")
    def workteam_arn(self) -> 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")

    @property
    @pulumi.getter(name="publicWorkforceTaskPrice")
    def public_workforce_task_price(self) -> Optional['outputs.FlowDefinitionHumanLoopConfigPublicWorkforceTaskPrice']:
        """
        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")

    @property
    @pulumi.getter(name="taskAvailabilityLifetimeInSeconds")
    def task_availability_lifetime_in_seconds(self) -> Optional[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")

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

    @property
    @pulumi.getter(name="taskTimeLimitInSeconds")
    def task_time_limit_in_seconds(self) -> Optional[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")


@pulumi.output_type
class FlowDefinitionHumanLoopConfigPublicWorkforceTaskPrice(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "amountInUsd":
            suggest = "amount_in_usd"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in FlowDefinitionHumanLoopConfigPublicWorkforceTaskPrice. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        FlowDefinitionHumanLoopConfigPublicWorkforceTaskPrice.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        FlowDefinitionHumanLoopConfigPublicWorkforceTaskPrice.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 amount_in_usd: Optional['outputs.FlowDefinitionHumanLoopConfigPublicWorkforceTaskPriceAmountInUsd'] = None):
        """
        :param '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['outputs.FlowDefinitionHumanLoopConfigPublicWorkforceTaskPriceAmountInUsd']:
        """
        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")


@pulumi.output_type
class FlowDefinitionHumanLoopConfigPublicWorkforceTaskPriceAmountInUsd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "tenthFractionsOfACent":
            suggest = "tenth_fractions_of_a_cent"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in FlowDefinitionHumanLoopConfigPublicWorkforceTaskPriceAmountInUsd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        FlowDefinitionHumanLoopConfigPublicWorkforceTaskPriceAmountInUsd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        FlowDefinitionHumanLoopConfigPublicWorkforceTaskPriceAmountInUsd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cents: Optional[int] = None,
                 dollars: Optional[int] = None,
                 tenth_fractions_of_a_cent: Optional[int] = None):
        """
        :param int cents: The fractional portion, in cents, of the amount. Valid value range between `0` and `99`.
        :param int dollars: The whole number of dollars in the amount. Valid value range between `0` and `2`.
        :param 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[int]:
        """
        The fractional portion, in cents, of the amount. Valid value range between `0` and `99`.
        """
        return pulumi.get(self, "cents")

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

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


@pulumi.output_type
class FlowDefinitionHumanLoopRequestSource(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "awsManagedHumanLoopRequestSource":
            suggest = "aws_managed_human_loop_request_source"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in FlowDefinitionHumanLoopRequestSource. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        FlowDefinitionHumanLoopRequestSource.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        FlowDefinitionHumanLoopRequestSource.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 aws_managed_human_loop_request_source: str):
        """
        :param 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) -> 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")


@pulumi.output_type
class FlowDefinitionOutputConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "s3OutputPath":
            suggest = "s3_output_path"
        elif key == "kmsKeyId":
            suggest = "kms_key_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in FlowDefinitionOutputConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        FlowDefinitionOutputConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        FlowDefinitionOutputConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 s3_output_path: str,
                 kms_key_id: Optional[str] = None):
        """
        :param str s3_output_path: The Amazon S3 path where the object containing human output will be made available.
        :param 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) -> str:
        """
        The Amazon S3 path where the object containing human output will be made available.
        """
        return pulumi.get(self, "s3_output_path")

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


@pulumi.output_type
class HumanTaskUIUiTemplate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "contentSha256":
            suggest = "content_sha256"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in HumanTaskUIUiTemplate. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        HumanTaskUIUiTemplate.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        HumanTaskUIUiTemplate.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 content: Optional[str] = None,
                 content_sha256: Optional[str] = None,
                 url: Optional[str] = None):
        """
        :param str content: The content of the Liquid template for the worker user interface.
        :param str content_sha256: The SHA-256 digest of the contents of the template.
        :param 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[str]:
        """
        The content of the Liquid template for the worker user interface.
        """
        return pulumi.get(self, "content")

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

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


@pulumi.output_type
class ModelContainer(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "containerHostname":
            suggest = "container_hostname"
        elif key == "imageConfig":
            suggest = "image_config"
        elif key == "modelDataUrl":
            suggest = "model_data_url"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ModelContainer. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ModelContainer.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ModelContainer.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 image: str,
                 container_hostname: Optional[str] = None,
                 environment: Optional[Mapping[str, str]] = None,
                 image_config: Optional['outputs.ModelContainerImageConfig'] = None,
                 mode: Optional[str] = None,
                 model_data_url: Optional[str] = None):
        """
        :param str image: The registry path where the inference code image is stored in Amazon ECR.
        :param str container_hostname: The DNS host name for the container.
        :param Mapping[str, str] environment: Environment variables for the Docker container.
               A list of key value pairs.
        :param '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 str mode: The container hosts value `SingleModel/MultiModel`. The default value is `SingleModel`.
        :param 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) -> str:
        """
        The registry path where the inference code image is stored in Amazon ECR.
        """
        return pulumi.get(self, "image")

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

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

    @property
    @pulumi.getter(name="imageConfig")
    def image_config(self) -> Optional['outputs.ModelContainerImageConfig']:
        """
        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")

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

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


@pulumi.output_type
class ModelContainerImageConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "repositoryAccessMode":
            suggest = "repository_access_mode"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ModelContainerImageConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ModelContainerImageConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ModelContainerImageConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 repository_access_mode: str):
        """
        :param 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) -> 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")


@pulumi.output_type
class ModelInferenceExecutionConfig(dict):
    def __init__(__self__, *,
                 mode: str):
        """
        :param str mode: The container hosts value `SingleModel/MultiModel`. The default value is `SingleModel`.
        """
        pulumi.set(__self__, "mode", mode)

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


@pulumi.output_type
class ModelPrimaryContainer(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "containerHostname":
            suggest = "container_hostname"
        elif key == "imageConfig":
            suggest = "image_config"
        elif key == "modelDataUrl":
            suggest = "model_data_url"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ModelPrimaryContainer. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ModelPrimaryContainer.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ModelPrimaryContainer.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 image: str,
                 container_hostname: Optional[str] = None,
                 environment: Optional[Mapping[str, str]] = None,
                 image_config: Optional['outputs.ModelPrimaryContainerImageConfig'] = None,
                 mode: Optional[str] = None,
                 model_data_url: Optional[str] = None):
        """
        :param str image: The registry path where the inference code image is stored in Amazon ECR.
        :param str container_hostname: The DNS host name for the container.
        :param Mapping[str, str] environment: Environment variables for the Docker container.
               A list of key value pairs.
        :param '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 str mode: The container hosts value `SingleModel/MultiModel`. The default value is `SingleModel`.
        :param 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) -> str:
        """
        The registry path where the inference code image is stored in Amazon ECR.
        """
        return pulumi.get(self, "image")

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

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

    @property
    @pulumi.getter(name="imageConfig")
    def image_config(self) -> Optional['outputs.ModelPrimaryContainerImageConfig']:
        """
        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")

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

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


@pulumi.output_type
class ModelPrimaryContainerImageConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "repositoryAccessMode":
            suggest = "repository_access_mode"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ModelPrimaryContainerImageConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ModelPrimaryContainerImageConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ModelPrimaryContainerImageConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 repository_access_mode: str):
        """
        :param 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) -> 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")


@pulumi.output_type
class ModelVpcConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "securityGroupIds":
            suggest = "security_group_ids"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ModelVpcConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ModelVpcConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ModelVpcConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 security_group_ids: Sequence[str],
                 subnets: Sequence[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) -> Sequence[str]:
        return pulumi.get(self, "security_group_ids")

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


@pulumi.output_type
class ProjectServiceCatalogProvisioningDetails(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "productId":
            suggest = "product_id"
        elif key == "pathId":
            suggest = "path_id"
        elif key == "provisioningArtifactId":
            suggest = "provisioning_artifact_id"
        elif key == "provisioningParameters":
            suggest = "provisioning_parameters"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ProjectServiceCatalogProvisioningDetails. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ProjectServiceCatalogProvisioningDetails.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ProjectServiceCatalogProvisioningDetails.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 product_id: str,
                 path_id: Optional[str] = None,
                 provisioning_artifact_id: Optional[str] = None,
                 provisioning_parameters: Optional[Sequence['outputs.ProjectServiceCatalogProvisioningDetailsProvisioningParameter']] = None):
        """
        :param str product_id: The ID of the product to provision.
        :param str path_id: The path identifier of the product. This value is optional if the product has a default path, and required if the product has more than one path.
        :param str provisioning_artifact_id: The ID of the provisioning artifact.
        :param Sequence['ProjectServiceCatalogProvisioningDetailsProvisioningParameterArgs'] provisioning_parameters: A list of key value pairs that you specify when you provision a product. See Provisioning Parameter below.
        """
        pulumi.set(__self__, "product_id", product_id)
        if path_id is not None:
            pulumi.set(__self__, "path_id", path_id)
        if provisioning_artifact_id is not None:
            pulumi.set(__self__, "provisioning_artifact_id", provisioning_artifact_id)
        if provisioning_parameters is not None:
            pulumi.set(__self__, "provisioning_parameters", provisioning_parameters)

    @property
    @pulumi.getter(name="productId")
    def product_id(self) -> str:
        """
        The ID of the product to provision.
        """
        return pulumi.get(self, "product_id")

    @property
    @pulumi.getter(name="pathId")
    def path_id(self) -> Optional[str]:
        """
        The path identifier of the product. This value is optional if the product has a default path, and required if the product has more than one path.
        """
        return pulumi.get(self, "path_id")

    @property
    @pulumi.getter(name="provisioningArtifactId")
    def provisioning_artifact_id(self) -> Optional[str]:
        """
        The ID of the provisioning artifact.
        """
        return pulumi.get(self, "provisioning_artifact_id")

    @property
    @pulumi.getter(name="provisioningParameters")
    def provisioning_parameters(self) -> Optional[Sequence['outputs.ProjectServiceCatalogProvisioningDetailsProvisioningParameter']]:
        """
        A list of key value pairs that you specify when you provision a product. See Provisioning Parameter below.
        """
        return pulumi.get(self, "provisioning_parameters")


@pulumi.output_type
class ProjectServiceCatalogProvisioningDetailsProvisioningParameter(dict):
    def __init__(__self__, *,
                 key: str,
                 value: Optional[str] = None):
        """
        :param str key: The key that identifies a provisioning parameter.
        :param str value: The value of the provisioning parameter.
        """
        pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The key that identifies a provisioning parameter.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        """
        The value of the provisioning parameter.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class UserProfileUserSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "executionRole":
            suggest = "execution_role"
        elif key == "jupyterServerAppSettings":
            suggest = "jupyter_server_app_settings"
        elif key == "kernelGatewayAppSettings":
            suggest = "kernel_gateway_app_settings"
        elif key == "securityGroups":
            suggest = "security_groups"
        elif key == "sharingSettings":
            suggest = "sharing_settings"
        elif key == "tensorBoardAppSettings":
            suggest = "tensor_board_app_settings"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in UserProfileUserSettings. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        UserProfileUserSettings.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        UserProfileUserSettings.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 execution_role: str,
                 jupyter_server_app_settings: Optional['outputs.UserProfileUserSettingsJupyterServerAppSettings'] = None,
                 kernel_gateway_app_settings: Optional['outputs.UserProfileUserSettingsKernelGatewayAppSettings'] = None,
                 security_groups: Optional[Sequence[str]] = None,
                 sharing_settings: Optional['outputs.UserProfileUserSettingsSharingSettings'] = None,
                 tensor_board_app_settings: Optional['outputs.UserProfileUserSettingsTensorBoardAppSettings'] = None):
        """
        :param str execution_role: The execution role ARN for the user.
        :param 'UserProfileUserSettingsJupyterServerAppSettingsArgs' jupyter_server_app_settings: The Jupyter server's app settings. See Jupyter Server App Settings below.
        :param 'UserProfileUserSettingsKernelGatewayAppSettingsArgs' kernel_gateway_app_settings: The kernel gateway app settings. See Kernel Gateway App Settings below.
        :param Sequence[str] security_groups: The security groups.
        :param 'UserProfileUserSettingsSharingSettingsArgs' sharing_settings: The sharing settings. See Sharing Settings below.
        :param '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) -> str:
        """
        The execution role ARN for the user.
        """
        return pulumi.get(self, "execution_role")

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

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

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

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

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


@pulumi.output_type
class UserProfileUserSettingsJupyterServerAppSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultResourceSpec":
            suggest = "default_resource_spec"
        elif key == "lifecycleConfigArns":
            suggest = "lifecycle_config_arns"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in UserProfileUserSettingsJupyterServerAppSettings. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        UserProfileUserSettingsJupyterServerAppSettings.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        UserProfileUserSettingsJupyterServerAppSettings.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 default_resource_spec: 'outputs.UserProfileUserSettingsJupyterServerAppSettingsDefaultResourceSpec',
                 lifecycle_config_arns: Optional[Sequence[str]] = None):
        """
        :param '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 Sequence[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) -> 'outputs.UserProfileUserSettingsJupyterServerAppSettingsDefaultResourceSpec':
        """
        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")

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


@pulumi.output_type
class UserProfileUserSettingsJupyterServerAppSettingsDefaultResourceSpec(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instanceType":
            suggest = "instance_type"
        elif key == "lifecycleConfigArn":
            suggest = "lifecycle_config_arn"
        elif key == "sagemakerImageArn":
            suggest = "sagemaker_image_arn"
        elif key == "sagemakerImageVersionArn":
            suggest = "sagemaker_image_version_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in UserProfileUserSettingsJupyterServerAppSettingsDefaultResourceSpec. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        UserProfileUserSettingsJupyterServerAppSettingsDefaultResourceSpec.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        UserProfileUserSettingsJupyterServerAppSettingsDefaultResourceSpec.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 instance_type: Optional[str] = None,
                 lifecycle_config_arn: Optional[str] = None,
                 sagemaker_image_arn: Optional[str] = None,
                 sagemaker_image_version_arn: Optional[str] = None):
        """
        :param str instance_type: The instance type.
        :param str lifecycle_config_arn: The Amazon Resource Name (ARN) of the Lifecycle Configuration attached to the Resource.
        :param str sagemaker_image_arn: The Amazon Resource Name (ARN) of the SageMaker image created on the instance.
        :param str sagemaker_image_version_arn: The ARN of the image version created on the instance.
        """
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if lifecycle_config_arn is not None:
            pulumi.set(__self__, "lifecycle_config_arn", lifecycle_config_arn)
        if sagemaker_image_arn is not None:
            pulumi.set(__self__, "sagemaker_image_arn", sagemaker_image_arn)
        if sagemaker_image_version_arn is not None:
            pulumi.set(__self__, "sagemaker_image_version_arn", sagemaker_image_version_arn)

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

    @property
    @pulumi.getter(name="lifecycleConfigArn")
    def lifecycle_config_arn(self) -> Optional[str]:
        """
        The Amazon Resource Name (ARN) of the Lifecycle Configuration attached to the Resource.
        """
        return pulumi.get(self, "lifecycle_config_arn")

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

    @property
    @pulumi.getter(name="sagemakerImageVersionArn")
    def sagemaker_image_version_arn(self) -> Optional[str]:
        """
        The ARN of the image version created on the instance.
        """
        return pulumi.get(self, "sagemaker_image_version_arn")


@pulumi.output_type
class UserProfileUserSettingsKernelGatewayAppSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultResourceSpec":
            suggest = "default_resource_spec"
        elif key == "customImages":
            suggest = "custom_images"
        elif key == "lifecycleConfigArns":
            suggest = "lifecycle_config_arns"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in UserProfileUserSettingsKernelGatewayAppSettings. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        UserProfileUserSettingsKernelGatewayAppSettings.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        UserProfileUserSettingsKernelGatewayAppSettings.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 default_resource_spec: 'outputs.UserProfileUserSettingsKernelGatewayAppSettingsDefaultResourceSpec',
                 custom_images: Optional[Sequence['outputs.UserProfileUserSettingsKernelGatewayAppSettingsCustomImage']] = None,
                 lifecycle_config_arns: Optional[Sequence[str]] = None):
        """
        :param '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 Sequence['UserProfileUserSettingsKernelGatewayAppSettingsCustomImageArgs'] custom_images: A list of custom SageMaker images that are configured to run as a KernelGateway app. see Custom Image below.
        :param Sequence[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) -> 'outputs.UserProfileUserSettingsKernelGatewayAppSettingsDefaultResourceSpec':
        """
        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")

    @property
    @pulumi.getter(name="customImages")
    def custom_images(self) -> Optional[Sequence['outputs.UserProfileUserSettingsKernelGatewayAppSettingsCustomImage']]:
        """
        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")

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


@pulumi.output_type
class UserProfileUserSettingsKernelGatewayAppSettingsCustomImage(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "appImageConfigName":
            suggest = "app_image_config_name"
        elif key == "imageName":
            suggest = "image_name"
        elif key == "imageVersionNumber":
            suggest = "image_version_number"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in UserProfileUserSettingsKernelGatewayAppSettingsCustomImage. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        UserProfileUserSettingsKernelGatewayAppSettingsCustomImage.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        UserProfileUserSettingsKernelGatewayAppSettingsCustomImage.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 app_image_config_name: str,
                 image_name: str,
                 image_version_number: Optional[int] = None):
        """
        :param str app_image_config_name: The name of the App Image Config.
        :param str image_name: The name of the Custom Image.
        :param 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) -> str:
        """
        The name of the App Image Config.
        """
        return pulumi.get(self, "app_image_config_name")

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

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


@pulumi.output_type
class UserProfileUserSettingsKernelGatewayAppSettingsDefaultResourceSpec(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instanceType":
            suggest = "instance_type"
        elif key == "lifecycleConfigArn":
            suggest = "lifecycle_config_arn"
        elif key == "sagemakerImageArn":
            suggest = "sagemaker_image_arn"
        elif key == "sagemakerImageVersionArn":
            suggest = "sagemaker_image_version_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in UserProfileUserSettingsKernelGatewayAppSettingsDefaultResourceSpec. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        UserProfileUserSettingsKernelGatewayAppSettingsDefaultResourceSpec.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        UserProfileUserSettingsKernelGatewayAppSettingsDefaultResourceSpec.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 instance_type: Optional[str] = None,
                 lifecycle_config_arn: Optional[str] = None,
                 sagemaker_image_arn: Optional[str] = None,
                 sagemaker_image_version_arn: Optional[str] = None):
        """
        :param str instance_type: The instance type.
        :param str lifecycle_config_arn: The Amazon Resource Name (ARN) of the Lifecycle Configuration attached to the Resource.
        :param str sagemaker_image_arn: The Amazon Resource Name (ARN) of the SageMaker image created on the instance.
        :param str sagemaker_image_version_arn: The ARN of the image version created on the instance.
        """
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if lifecycle_config_arn is not None:
            pulumi.set(__self__, "lifecycle_config_arn", lifecycle_config_arn)
        if sagemaker_image_arn is not None:
            pulumi.set(__self__, "sagemaker_image_arn", sagemaker_image_arn)
        if sagemaker_image_version_arn is not None:
            pulumi.set(__self__, "sagemaker_image_version_arn", sagemaker_image_version_arn)

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

    @property
    @pulumi.getter(name="lifecycleConfigArn")
    def lifecycle_config_arn(self) -> Optional[str]:
        """
        The Amazon Resource Name (ARN) of the Lifecycle Configuration attached to the Resource.
        """
        return pulumi.get(self, "lifecycle_config_arn")

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

    @property
    @pulumi.getter(name="sagemakerImageVersionArn")
    def sagemaker_image_version_arn(self) -> Optional[str]:
        """
        The ARN of the image version created on the instance.
        """
        return pulumi.get(self, "sagemaker_image_version_arn")


@pulumi.output_type
class UserProfileUserSettingsSharingSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "notebookOutputOption":
            suggest = "notebook_output_option"
        elif key == "s3KmsKeyId":
            suggest = "s3_kms_key_id"
        elif key == "s3OutputPath":
            suggest = "s3_output_path"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in UserProfileUserSettingsSharingSettings. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        UserProfileUserSettingsSharingSettings.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        UserProfileUserSettingsSharingSettings.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 notebook_output_option: Optional[str] = None,
                 s3_kms_key_id: Optional[str] = None,
                 s3_output_path: Optional[str] = None):
        """
        :param 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 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 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[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")

    @property
    @pulumi.getter(name="s3KmsKeyId")
    def s3_kms_key_id(self) -> Optional[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")

    @property
    @pulumi.getter(name="s3OutputPath")
    def s3_output_path(self) -> Optional[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")


@pulumi.output_type
class UserProfileUserSettingsTensorBoardAppSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultResourceSpec":
            suggest = "default_resource_spec"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in UserProfileUserSettingsTensorBoardAppSettings. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        UserProfileUserSettingsTensorBoardAppSettings.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        UserProfileUserSettingsTensorBoardAppSettings.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 default_resource_spec: 'outputs.UserProfileUserSettingsTensorBoardAppSettingsDefaultResourceSpec'):
        """
        :param '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) -> 'outputs.UserProfileUserSettingsTensorBoardAppSettingsDefaultResourceSpec':
        """
        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")


@pulumi.output_type
class UserProfileUserSettingsTensorBoardAppSettingsDefaultResourceSpec(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instanceType":
            suggest = "instance_type"
        elif key == "lifecycleConfigArn":
            suggest = "lifecycle_config_arn"
        elif key == "sagemakerImageArn":
            suggest = "sagemaker_image_arn"
        elif key == "sagemakerImageVersionArn":
            suggest = "sagemaker_image_version_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in UserProfileUserSettingsTensorBoardAppSettingsDefaultResourceSpec. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        UserProfileUserSettingsTensorBoardAppSettingsDefaultResourceSpec.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        UserProfileUserSettingsTensorBoardAppSettingsDefaultResourceSpec.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 instance_type: Optional[str] = None,
                 lifecycle_config_arn: Optional[str] = None,
                 sagemaker_image_arn: Optional[str] = None,
                 sagemaker_image_version_arn: Optional[str] = None):
        """
        :param str instance_type: The instance type.
        :param str lifecycle_config_arn: The Amazon Resource Name (ARN) of the Lifecycle Configuration attached to the Resource.
        :param str sagemaker_image_arn: The Amazon Resource Name (ARN) of the SageMaker image created on the instance.
        :param str sagemaker_image_version_arn: The ARN of the image version created on the instance.
        """
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if lifecycle_config_arn is not None:
            pulumi.set(__self__, "lifecycle_config_arn", lifecycle_config_arn)
        if sagemaker_image_arn is not None:
            pulumi.set(__self__, "sagemaker_image_arn", sagemaker_image_arn)
        if sagemaker_image_version_arn is not None:
            pulumi.set(__self__, "sagemaker_image_version_arn", sagemaker_image_version_arn)

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

    @property
    @pulumi.getter(name="lifecycleConfigArn")
    def lifecycle_config_arn(self) -> Optional[str]:
        """
        The Amazon Resource Name (ARN) of the Lifecycle Configuration attached to the Resource.
        """
        return pulumi.get(self, "lifecycle_config_arn")

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

    @property
    @pulumi.getter(name="sagemakerImageVersionArn")
    def sagemaker_image_version_arn(self) -> Optional[str]:
        """
        The ARN of the image version created on the instance.
        """
        return pulumi.get(self, "sagemaker_image_version_arn")


@pulumi.output_type
class WorkforceCognitoConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientId":
            suggest = "client_id"
        elif key == "userPool":
            suggest = "user_pool"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in WorkforceCognitoConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        WorkforceCognitoConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        WorkforceCognitoConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 client_id: str,
                 user_pool: str):
        """
        :param str client_id: The OIDC IdP client ID used to configure your private workforce.
        :param 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) -> str:
        """
        The OIDC IdP client ID used to configure your private workforce.
        """
        return pulumi.get(self, "client_id")

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


@pulumi.output_type
class WorkforceOidcConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "authorizationEndpoint":
            suggest = "authorization_endpoint"
        elif key == "clientId":
            suggest = "client_id"
        elif key == "clientSecret":
            suggest = "client_secret"
        elif key == "jwksUri":
            suggest = "jwks_uri"
        elif key == "logoutEndpoint":
            suggest = "logout_endpoint"
        elif key == "tokenEndpoint":
            suggest = "token_endpoint"
        elif key == "userInfoEndpoint":
            suggest = "user_info_endpoint"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in WorkforceOidcConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        WorkforceOidcConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        WorkforceOidcConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 authorization_endpoint: str,
                 client_id: str,
                 client_secret: str,
                 issuer: str,
                 jwks_uri: str,
                 logout_endpoint: str,
                 token_endpoint: str,
                 user_info_endpoint: str):
        """
        :param str authorization_endpoint: The OIDC IdP authorization endpoint used to configure your private workforce.
        :param str client_id: The OIDC IdP client ID used to configure your private workforce.
        :param str client_secret: The OIDC IdP client secret used to configure your private workforce.
        :param str issuer: The OIDC IdP issuer used to configure your private workforce.
        :param str jwks_uri: The OIDC IdP JSON Web Key Set (Jwks) URI used to configure your private workforce.
        :param str logout_endpoint: The OIDC IdP logout endpoint used to configure your private workforce.
        :param str token_endpoint: The OIDC IdP token endpoint used to configure your private workforce.
        :param 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) -> str:
        """
        The OIDC IdP authorization endpoint used to configure your private workforce.
        """
        return pulumi.get(self, "authorization_endpoint")

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

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

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

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

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

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

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


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

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


@pulumi.output_type
class WorkteamMemberDefinition(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cognitoMemberDefinition":
            suggest = "cognito_member_definition"
        elif key == "oidcMemberDefinition":
            suggest = "oidc_member_definition"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in WorkteamMemberDefinition. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        WorkteamMemberDefinition.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        WorkteamMemberDefinition.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cognito_member_definition: Optional['outputs.WorkteamMemberDefinitionCognitoMemberDefinition'] = None,
                 oidc_member_definition: Optional['outputs.WorkteamMemberDefinitionOidcMemberDefinition'] = None):
        """
        :param 'WorkteamMemberDefinitionCognitoMemberDefinitionArgs' cognito_member_definition: The Amazon Cognito user group that is part of the work team. See Cognito Member Definition details below.
        :param '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['outputs.WorkteamMemberDefinitionCognitoMemberDefinition']:
        """
        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")

    @property
    @pulumi.getter(name="oidcMemberDefinition")
    def oidc_member_definition(self) -> Optional['outputs.WorkteamMemberDefinitionOidcMemberDefinition']:
        """
        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")


@pulumi.output_type
class WorkteamMemberDefinitionCognitoMemberDefinition(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientId":
            suggest = "client_id"
        elif key == "userGroup":
            suggest = "user_group"
        elif key == "userPool":
            suggest = "user_pool"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in WorkteamMemberDefinitionCognitoMemberDefinition. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        WorkteamMemberDefinitionCognitoMemberDefinition.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        WorkteamMemberDefinitionCognitoMemberDefinition.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 client_id: str,
                 user_group: str,
                 user_pool: str):
        """
        :param str client_id: An identifier for an application client. You must create the app client ID using Amazon Cognito.
        :param str user_group: An identifier for a user group.
        :param 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) -> str:
        """
        An identifier for an application client. You must create the app client ID using Amazon Cognito.
        """
        return pulumi.get(self, "client_id")

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

    @property
    @pulumi.getter(name="userPool")
    def user_pool(self) -> 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")


@pulumi.output_type
class WorkteamMemberDefinitionOidcMemberDefinition(dict):
    def __init__(__self__, *,
                 groups: Sequence[str]):
        """
        :param Sequence[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) -> Sequence[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")


@pulumi.output_type
class WorkteamNotificationConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "notificationTopicArn":
            suggest = "notification_topic_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in WorkteamNotificationConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        WorkteamNotificationConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        WorkteamNotificationConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 notification_topic_arn: Optional[str] = None):
        """
        :param 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[str]:
        """
        The ARN for the SNS topic to which notifications should be published.
        """
        return pulumi.get(self, "notification_topic_arn")


