# coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** 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 ._enums import *

__all__ = [
    'AnalysisAnalysisErrorArgs',
    'AnalysisAnalysisSourceEntityArgs',
    'AnalysisAnalysisSourceTemplateArgs',
    'AnalysisDataSetReferenceArgs',
    'AnalysisDateTimeParameterArgs',
    'AnalysisDecimalParameterArgs',
    'AnalysisIntegerParameterArgs',
    'AnalysisParametersArgs',
    'AnalysisResourcePermissionArgs',
    'AnalysisStringParameterArgs',
    'AnalysisTagArgs',
    'DashboardAdHocFilteringOptionArgs',
    'DashboardDashboardPublishOptionsArgs',
    'DashboardDashboardSourceEntityArgs',
    'DashboardDashboardSourceTemplateArgs',
    'DashboardDataSetReferenceArgs',
    'DashboardDateTimeParameterArgs',
    'DashboardDecimalParameterArgs',
    'DashboardExportToCSVOptionArgs',
    'DashboardIntegerParameterArgs',
    'DashboardParametersArgs',
    'DashboardResourcePermissionArgs',
    'DashboardSheetControlsOptionArgs',
    'DashboardStringParameterArgs',
    'DashboardTagArgs',
    'DataSetColumnGroupArgs',
    'DataSetColumnLevelPermissionRuleArgs',
    'DataSetFieldFolderMapArgs',
    'DataSetGeoSpatialColumnGroupArgs',
    'DataSetIngestionWaitPolicyArgs',
    'DataSetLogicalTableMapArgs',
    'DataSetPhysicalTableMapArgs',
    'DataSetResourcePermissionArgs',
    'DataSetRowLevelPermissionDataSetArgs',
    'DataSetTagArgs',
    'DataSourceAmazonElasticsearchParametersArgs',
    'DataSourceAthenaParametersArgs',
    'DataSourceAuroraParametersArgs',
    'DataSourceAuroraPostgreSqlParametersArgs',
    'DataSourceCredentialPairArgs',
    'DataSourceDataSourceCredentialsArgs',
    'DataSourceDataSourceErrorInfoArgs',
    'DataSourceDataSourceParametersArgs',
    'DataSourceManifestFileLocationArgs',
    'DataSourceMariaDbParametersArgs',
    'DataSourceMySqlParametersArgs',
    'DataSourceOracleParametersArgs',
    'DataSourcePostgreSqlParametersArgs',
    'DataSourcePrestoParametersArgs',
    'DataSourceRdsParametersArgs',
    'DataSourceRedshiftParametersArgs',
    'DataSourceResourcePermissionArgs',
    'DataSourceS3ParametersArgs',
    'DataSourceSnowflakeParametersArgs',
    'DataSourceSparkParametersArgs',
    'DataSourceSqlServerParametersArgs',
    'DataSourceSslPropertiesArgs',
    'DataSourceTagArgs',
    'DataSourceTeradataParametersArgs',
    'DataSourceVpcConnectionPropertiesArgs',
    'TemplateDataSetReferenceArgs',
    'TemplateResourcePermissionArgs',
    'TemplateTagArgs',
    'TemplateTemplateSourceAnalysisArgs',
    'TemplateTemplateSourceEntityArgs',
    'TemplateTemplateSourceTemplateArgs',
    'ThemeBorderStyleArgs',
    'ThemeDataColorPaletteArgs',
    'ThemeFontArgs',
    'ThemeGutterStyleArgs',
    'ThemeMarginStyleArgs',
    'ThemeResourcePermissionArgs',
    'ThemeSheetStyleArgs',
    'ThemeTagArgs',
    'ThemeThemeConfigurationArgs',
    'ThemeTileLayoutStyleArgs',
    'ThemeTileStyleArgs',
    'ThemeTypographyArgs',
    'ThemeUIColorPaletteArgs',
]

@pulumi.input_type
class AnalysisAnalysisErrorArgs:
    def __init__(__self__, *,
                 message: Optional[pulumi.Input[str]] = None,
                 type: Optional[pulumi.Input['AnalysisAnalysisErrorType']] = None):
        """
        <p>A metadata error structure for an analysis.</p>
        :param pulumi.Input[str] message: <p>The message associated with the analysis error.</p>
        """
        if message is not None:
            pulumi.set(__self__, "message", message)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def message(self) -> Optional[pulumi.Input[str]]:
        """
        <p>The message associated with the analysis error.</p>
        """
        return pulumi.get(self, "message")

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

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input['AnalysisAnalysisErrorType']]:
        return pulumi.get(self, "type")

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


@pulumi.input_type
class AnalysisAnalysisSourceEntityArgs:
    def __init__(__self__, *,
                 source_template: Optional[pulumi.Input['AnalysisAnalysisSourceTemplateArgs']] = None):
        """
        <p>The source entity of an analysis.</p>
        """
        if source_template is not None:
            pulumi.set(__self__, "source_template", source_template)

    @property
    @pulumi.getter(name="sourceTemplate")
    def source_template(self) -> Optional[pulumi.Input['AnalysisAnalysisSourceTemplateArgs']]:
        return pulumi.get(self, "source_template")

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


@pulumi.input_type
class AnalysisAnalysisSourceTemplateArgs:
    def __init__(__self__, *,
                 arn: pulumi.Input[str],
                 data_set_references: pulumi.Input[Sequence[pulumi.Input['AnalysisDataSetReferenceArgs']]]):
        """
        <p>The source template of an analysis.</p>
        :param pulumi.Input[str] arn: <p>The Amazon Resource Name (ARN) of the source template of an analysis.</p>
        :param pulumi.Input[Sequence[pulumi.Input['AnalysisDataSetReferenceArgs']]] data_set_references: <p>The dataset references of the source template of an analysis.</p>
        """
        pulumi.set(__self__, "arn", arn)
        pulumi.set(__self__, "data_set_references", data_set_references)

    @property
    @pulumi.getter
    def arn(self) -> pulumi.Input[str]:
        """
        <p>The Amazon Resource Name (ARN) of the source template of an analysis.</p>
        """
        return pulumi.get(self, "arn")

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

    @property
    @pulumi.getter(name="dataSetReferences")
    def data_set_references(self) -> pulumi.Input[Sequence[pulumi.Input['AnalysisDataSetReferenceArgs']]]:
        """
        <p>The dataset references of the source template of an analysis.</p>
        """
        return pulumi.get(self, "data_set_references")

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


@pulumi.input_type
class AnalysisDataSetReferenceArgs:
    def __init__(__self__, *,
                 data_set_arn: pulumi.Input[str],
                 data_set_placeholder: pulumi.Input[str]):
        """
        <p>Dataset reference.</p>
        :param pulumi.Input[str] data_set_arn: <p>Dataset Amazon Resource Name (ARN).</p>
        :param pulumi.Input[str] data_set_placeholder: <p>Dataset placeholder.</p>
        """
        pulumi.set(__self__, "data_set_arn", data_set_arn)
        pulumi.set(__self__, "data_set_placeholder", data_set_placeholder)

    @property
    @pulumi.getter(name="dataSetArn")
    def data_set_arn(self) -> pulumi.Input[str]:
        """
        <p>Dataset Amazon Resource Name (ARN).</p>
        """
        return pulumi.get(self, "data_set_arn")

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

    @property
    @pulumi.getter(name="dataSetPlaceholder")
    def data_set_placeholder(self) -> pulumi.Input[str]:
        """
        <p>Dataset placeholder.</p>
        """
        return pulumi.get(self, "data_set_placeholder")

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


@pulumi.input_type
class AnalysisDateTimeParameterArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 values: pulumi.Input[Sequence[pulumi.Input[str]]]):
        """
        <p>A date-time parameter.</p>
        :param pulumi.Input[str] name: <p>A display name for the date-time parameter.</p>
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: <p>The values for the date-time parameter.</p>
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        <p>A display name for the date-time parameter.</p>
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def values(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        <p>The values for the date-time parameter.</p>
        """
        return pulumi.get(self, "values")

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


@pulumi.input_type
class AnalysisDecimalParameterArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 values: pulumi.Input[Sequence[pulumi.Input[float]]]):
        """
        <p>A decimal parameter.</p>
        :param pulumi.Input[str] name: <p>A display name for the decimal parameter.</p>
        :param pulumi.Input[Sequence[pulumi.Input[float]]] values: <p>The values for the decimal parameter.</p>
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        <p>A display name for the decimal parameter.</p>
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def values(self) -> pulumi.Input[Sequence[pulumi.Input[float]]]:
        """
        <p>The values for the decimal parameter.</p>
        """
        return pulumi.get(self, "values")

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


@pulumi.input_type
class AnalysisIntegerParameterArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 values: pulumi.Input[Sequence[pulumi.Input[float]]]):
        """
        <p>An integer parameter.</p>
        :param pulumi.Input[str] name: <p>The name of the integer parameter.</p>
        :param pulumi.Input[Sequence[pulumi.Input[float]]] values: <p>The values for the integer parameter.</p>
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)

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

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

    @property
    @pulumi.getter
    def values(self) -> pulumi.Input[Sequence[pulumi.Input[float]]]:
        """
        <p>The values for the integer parameter.</p>
        """
        return pulumi.get(self, "values")

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


@pulumi.input_type
class AnalysisParametersArgs:
    def __init__(__self__, *,
                 date_time_parameters: Optional[pulumi.Input[Sequence[pulumi.Input['AnalysisDateTimeParameterArgs']]]] = None,
                 decimal_parameters: Optional[pulumi.Input[Sequence[pulumi.Input['AnalysisDecimalParameterArgs']]]] = None,
                 integer_parameters: Optional[pulumi.Input[Sequence[pulumi.Input['AnalysisIntegerParameterArgs']]]] = None,
                 string_parameters: Optional[pulumi.Input[Sequence[pulumi.Input['AnalysisStringParameterArgs']]]] = None):
        """
        <p>A list of QuickSight parameters and the list's override values.</p>
        :param pulumi.Input[Sequence[pulumi.Input['AnalysisDateTimeParameterArgs']]] date_time_parameters: <p>Date-time parameters.</p>
        :param pulumi.Input[Sequence[pulumi.Input['AnalysisDecimalParameterArgs']]] decimal_parameters: <p>Decimal parameters.</p>
        :param pulumi.Input[Sequence[pulumi.Input['AnalysisIntegerParameterArgs']]] integer_parameters: <p>Integer parameters.</p>
        :param pulumi.Input[Sequence[pulumi.Input['AnalysisStringParameterArgs']]] string_parameters: <p>String parameters.</p>
        """
        if date_time_parameters is not None:
            pulumi.set(__self__, "date_time_parameters", date_time_parameters)
        if decimal_parameters is not None:
            pulumi.set(__self__, "decimal_parameters", decimal_parameters)
        if integer_parameters is not None:
            pulumi.set(__self__, "integer_parameters", integer_parameters)
        if string_parameters is not None:
            pulumi.set(__self__, "string_parameters", string_parameters)

    @property
    @pulumi.getter(name="dateTimeParameters")
    def date_time_parameters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AnalysisDateTimeParameterArgs']]]]:
        """
        <p>Date-time parameters.</p>
        """
        return pulumi.get(self, "date_time_parameters")

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

    @property
    @pulumi.getter(name="decimalParameters")
    def decimal_parameters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AnalysisDecimalParameterArgs']]]]:
        """
        <p>Decimal parameters.</p>
        """
        return pulumi.get(self, "decimal_parameters")

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

    @property
    @pulumi.getter(name="integerParameters")
    def integer_parameters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AnalysisIntegerParameterArgs']]]]:
        """
        <p>Integer parameters.</p>
        """
        return pulumi.get(self, "integer_parameters")

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

    @property
    @pulumi.getter(name="stringParameters")
    def string_parameters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AnalysisStringParameterArgs']]]]:
        """
        <p>String parameters.</p>
        """
        return pulumi.get(self, "string_parameters")

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


@pulumi.input_type
class AnalysisResourcePermissionArgs:
    def __init__(__self__, *,
                 actions: pulumi.Input[Sequence[pulumi.Input[str]]],
                 principal: pulumi.Input[str]):
        """
        <p>Permission for the resource.</p>
        :param pulumi.Input[Sequence[pulumi.Input[str]]] actions: <p>The IAM action to grant or revoke permissions on.</p>
        :param pulumi.Input[str] principal: <p>The Amazon Resource Name (ARN) of the principal. This can be one of the
                           following:</p>
                       <ul>
                           <li>
                               <p>The ARN of an Amazon QuickSight user or group associated with a data source or dataset. (This is common.)</p>
                           </li>
                           <li>
                               <p>The ARN of an Amazon QuickSight user, group, or namespace associated with an analysis, dashboard, template, or theme. (This is common.)</p>
                           </li>
                           <li>
                               <p>The ARN of an AWS account root: This is an IAM ARN rather than a QuickSight
                                   ARN. Use this option only to share resources (templates) across AWS accounts.
                                   (This is less common.) </p>
                           </li>
                        </ul>
        """
        pulumi.set(__self__, "actions", actions)
        pulumi.set(__self__, "principal", principal)

    @property
    @pulumi.getter
    def actions(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        <p>The IAM action to grant or revoke permissions on.</p>
        """
        return pulumi.get(self, "actions")

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

    @property
    @pulumi.getter
    def principal(self) -> pulumi.Input[str]:
        """
        <p>The Amazon Resource Name (ARN) of the principal. This can be one of the
                    following:</p>
                <ul>
                    <li>
                        <p>The ARN of an Amazon QuickSight user or group associated with a data source or dataset. (This is common.)</p>
                    </li>
                    <li>
                        <p>The ARN of an Amazon QuickSight user, group, or namespace associated with an analysis, dashboard, template, or theme. (This is common.)</p>
                    </li>
                    <li>
                        <p>The ARN of an AWS account root: This is an IAM ARN rather than a QuickSight
                            ARN. Use this option only to share resources (templates) across AWS accounts.
                            (This is less common.) </p>
                    </li>
                 </ul>
        """
        return pulumi.get(self, "principal")

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


@pulumi.input_type
class AnalysisStringParameterArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 values: pulumi.Input[Sequence[pulumi.Input[str]]]):
        """
        <p>A string parameter.</p>
        :param pulumi.Input[str] name: <p>A display name for a string parameter.</p>
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: <p>The values of a string parameter.</p>
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        <p>A display name for a string parameter.</p>
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def values(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        <p>The values of a string parameter.</p>
        """
        return pulumi.get(self, "values")

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


@pulumi.input_type
class AnalysisTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        <p>The key or keys of the key-value pairs for the resource tag or tags assigned to the
                    resource.</p>
        :param pulumi.Input[str] key: <p>Tag key.</p>
        :param pulumi.Input[str] value: <p>Tag value.</p>
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        <p>Tag key.</p>
        """
        return pulumi.get(self, "key")

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

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        <p>Tag value.</p>
        """
        return pulumi.get(self, "value")

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


@pulumi.input_type
class DashboardAdHocFilteringOptionArgs:
    def __init__(__self__, *,
                 availability_status: Optional[pulumi.Input['DashboardDashboardBehavior']] = None):
        """
        <p>Ad hoc (one-time) filtering option.</p>
        """
        if availability_status is not None:
            pulumi.set(__self__, "availability_status", availability_status)

    @property
    @pulumi.getter(name="availabilityStatus")
    def availability_status(self) -> Optional[pulumi.Input['DashboardDashboardBehavior']]:
        return pulumi.get(self, "availability_status")

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


@pulumi.input_type
class DashboardDashboardPublishOptionsArgs:
    def __init__(__self__, *,
                 ad_hoc_filtering_option: Optional[pulumi.Input['DashboardAdHocFilteringOptionArgs']] = None,
                 export_to_csv_option: Optional[pulumi.Input['DashboardExportToCSVOptionArgs']] = None,
                 sheet_controls_option: Optional[pulumi.Input['DashboardSheetControlsOptionArgs']] = None):
        """
        <p>Dashboard publish options.</p>
        """
        if ad_hoc_filtering_option is not None:
            pulumi.set(__self__, "ad_hoc_filtering_option", ad_hoc_filtering_option)
        if export_to_csv_option is not None:
            pulumi.set(__self__, "export_to_csv_option", export_to_csv_option)
        if sheet_controls_option is not None:
            pulumi.set(__self__, "sheet_controls_option", sheet_controls_option)

    @property
    @pulumi.getter(name="adHocFilteringOption")
    def ad_hoc_filtering_option(self) -> Optional[pulumi.Input['DashboardAdHocFilteringOptionArgs']]:
        return pulumi.get(self, "ad_hoc_filtering_option")

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

    @property
    @pulumi.getter(name="exportToCSVOption")
    def export_to_csv_option(self) -> Optional[pulumi.Input['DashboardExportToCSVOptionArgs']]:
        return pulumi.get(self, "export_to_csv_option")

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

    @property
    @pulumi.getter(name="sheetControlsOption")
    def sheet_controls_option(self) -> Optional[pulumi.Input['DashboardSheetControlsOptionArgs']]:
        return pulumi.get(self, "sheet_controls_option")

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


@pulumi.input_type
class DashboardDashboardSourceEntityArgs:
    def __init__(__self__, *,
                 source_template: Optional[pulumi.Input['DashboardDashboardSourceTemplateArgs']] = None):
        """
        <p>Dashboard source entity.</p>
        """
        if source_template is not None:
            pulumi.set(__self__, "source_template", source_template)

    @property
    @pulumi.getter(name="sourceTemplate")
    def source_template(self) -> Optional[pulumi.Input['DashboardDashboardSourceTemplateArgs']]:
        return pulumi.get(self, "source_template")

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


@pulumi.input_type
class DashboardDashboardSourceTemplateArgs:
    def __init__(__self__, *,
                 arn: pulumi.Input[str],
                 data_set_references: pulumi.Input[Sequence[pulumi.Input['DashboardDataSetReferenceArgs']]]):
        """
        <p>Dashboard source template.</p>
        :param pulumi.Input[str] arn: <p>The Amazon Resource Name (ARN) of the resource.</p>
        :param pulumi.Input[Sequence[pulumi.Input['DashboardDataSetReferenceArgs']]] data_set_references: <p>Dataset references.</p>
        """
        pulumi.set(__self__, "arn", arn)
        pulumi.set(__self__, "data_set_references", data_set_references)

    @property
    @pulumi.getter
    def arn(self) -> pulumi.Input[str]:
        """
        <p>The Amazon Resource Name (ARN) of the resource.</p>
        """
        return pulumi.get(self, "arn")

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

    @property
    @pulumi.getter(name="dataSetReferences")
    def data_set_references(self) -> pulumi.Input[Sequence[pulumi.Input['DashboardDataSetReferenceArgs']]]:
        """
        <p>Dataset references.</p>
        """
        return pulumi.get(self, "data_set_references")

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


@pulumi.input_type
class DashboardDataSetReferenceArgs:
    def __init__(__self__, *,
                 data_set_arn: pulumi.Input[str],
                 data_set_placeholder: pulumi.Input[str]):
        """
        <p>Dataset reference.</p>
        :param pulumi.Input[str] data_set_arn: <p>Dataset Amazon Resource Name (ARN).</p>
        :param pulumi.Input[str] data_set_placeholder: <p>Dataset placeholder.</p>
        """
        pulumi.set(__self__, "data_set_arn", data_set_arn)
        pulumi.set(__self__, "data_set_placeholder", data_set_placeholder)

    @property
    @pulumi.getter(name="dataSetArn")
    def data_set_arn(self) -> pulumi.Input[str]:
        """
        <p>Dataset Amazon Resource Name (ARN).</p>
        """
        return pulumi.get(self, "data_set_arn")

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

    @property
    @pulumi.getter(name="dataSetPlaceholder")
    def data_set_placeholder(self) -> pulumi.Input[str]:
        """
        <p>Dataset placeholder.</p>
        """
        return pulumi.get(self, "data_set_placeholder")

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


@pulumi.input_type
class DashboardDateTimeParameterArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 values: pulumi.Input[Sequence[pulumi.Input[str]]]):
        """
        <p>A date-time parameter.</p>
        :param pulumi.Input[str] name: <p>A display name for the date-time parameter.</p>
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: <p>The values for the date-time parameter.</p>
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        <p>A display name for the date-time parameter.</p>
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def values(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        <p>The values for the date-time parameter.</p>
        """
        return pulumi.get(self, "values")

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


@pulumi.input_type
class DashboardDecimalParameterArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 values: pulumi.Input[Sequence[pulumi.Input[float]]]):
        """
        <p>A decimal parameter.</p>
        :param pulumi.Input[str] name: <p>A display name for the decimal parameter.</p>
        :param pulumi.Input[Sequence[pulumi.Input[float]]] values: <p>The values for the decimal parameter.</p>
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        <p>A display name for the decimal parameter.</p>
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def values(self) -> pulumi.Input[Sequence[pulumi.Input[float]]]:
        """
        <p>The values for the decimal parameter.</p>
        """
        return pulumi.get(self, "values")

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


@pulumi.input_type
class DashboardExportToCSVOptionArgs:
    def __init__(__self__, *,
                 availability_status: Optional[pulumi.Input['DashboardDashboardBehavior']] = None):
        """
        <p>Export to .csv option.</p>
        """
        if availability_status is not None:
            pulumi.set(__self__, "availability_status", availability_status)

    @property
    @pulumi.getter(name="availabilityStatus")
    def availability_status(self) -> Optional[pulumi.Input['DashboardDashboardBehavior']]:
        return pulumi.get(self, "availability_status")

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


@pulumi.input_type
class DashboardIntegerParameterArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 values: pulumi.Input[Sequence[pulumi.Input[float]]]):
        """
        <p>An integer parameter.</p>
        :param pulumi.Input[str] name: <p>The name of the integer parameter.</p>
        :param pulumi.Input[Sequence[pulumi.Input[float]]] values: <p>The values for the integer parameter.</p>
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)

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

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

    @property
    @pulumi.getter
    def values(self) -> pulumi.Input[Sequence[pulumi.Input[float]]]:
        """
        <p>The values for the integer parameter.</p>
        """
        return pulumi.get(self, "values")

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


@pulumi.input_type
class DashboardParametersArgs:
    def __init__(__self__, *,
                 date_time_parameters: Optional[pulumi.Input[Sequence[pulumi.Input['DashboardDateTimeParameterArgs']]]] = None,
                 decimal_parameters: Optional[pulumi.Input[Sequence[pulumi.Input['DashboardDecimalParameterArgs']]]] = None,
                 integer_parameters: Optional[pulumi.Input[Sequence[pulumi.Input['DashboardIntegerParameterArgs']]]] = None,
                 string_parameters: Optional[pulumi.Input[Sequence[pulumi.Input['DashboardStringParameterArgs']]]] = None):
        """
        <p>A list of QuickSight parameters and the list's override values.</p>
        :param pulumi.Input[Sequence[pulumi.Input['DashboardDateTimeParameterArgs']]] date_time_parameters: <p>Date-time parameters.</p>
        :param pulumi.Input[Sequence[pulumi.Input['DashboardDecimalParameterArgs']]] decimal_parameters: <p>Decimal parameters.</p>
        :param pulumi.Input[Sequence[pulumi.Input['DashboardIntegerParameterArgs']]] integer_parameters: <p>Integer parameters.</p>
        :param pulumi.Input[Sequence[pulumi.Input['DashboardStringParameterArgs']]] string_parameters: <p>String parameters.</p>
        """
        if date_time_parameters is not None:
            pulumi.set(__self__, "date_time_parameters", date_time_parameters)
        if decimal_parameters is not None:
            pulumi.set(__self__, "decimal_parameters", decimal_parameters)
        if integer_parameters is not None:
            pulumi.set(__self__, "integer_parameters", integer_parameters)
        if string_parameters is not None:
            pulumi.set(__self__, "string_parameters", string_parameters)

    @property
    @pulumi.getter(name="dateTimeParameters")
    def date_time_parameters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DashboardDateTimeParameterArgs']]]]:
        """
        <p>Date-time parameters.</p>
        """
        return pulumi.get(self, "date_time_parameters")

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

    @property
    @pulumi.getter(name="decimalParameters")
    def decimal_parameters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DashboardDecimalParameterArgs']]]]:
        """
        <p>Decimal parameters.</p>
        """
        return pulumi.get(self, "decimal_parameters")

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

    @property
    @pulumi.getter(name="integerParameters")
    def integer_parameters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DashboardIntegerParameterArgs']]]]:
        """
        <p>Integer parameters.</p>
        """
        return pulumi.get(self, "integer_parameters")

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

    @property
    @pulumi.getter(name="stringParameters")
    def string_parameters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DashboardStringParameterArgs']]]]:
        """
        <p>String parameters.</p>
        """
        return pulumi.get(self, "string_parameters")

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


@pulumi.input_type
class DashboardResourcePermissionArgs:
    def __init__(__self__, *,
                 actions: pulumi.Input[Sequence[pulumi.Input[str]]],
                 principal: pulumi.Input[str]):
        """
        <p>Permission for the resource.</p>
        :param pulumi.Input[Sequence[pulumi.Input[str]]] actions: <p>The IAM action to grant or revoke permissions on.</p>
        :param pulumi.Input[str] principal: <p>The Amazon Resource Name (ARN) of the principal. This can be one of the
                           following:</p>
                       <ul>
                           <li>
                               <p>The ARN of an Amazon QuickSight user or group associated with a data source or dataset. (This is common.)</p>
                           </li>
                           <li>
                               <p>The ARN of an Amazon QuickSight user, group, or namespace associated with an analysis, dashboard, template, or theme. (This is common.)</p>
                           </li>
                           <li>
                               <p>The ARN of an AWS account root: This is an IAM ARN rather than a QuickSight
                                   ARN. Use this option only to share resources (templates) across AWS accounts.
                                   (This is less common.) </p>
                           </li>
                        </ul>
        """
        pulumi.set(__self__, "actions", actions)
        pulumi.set(__self__, "principal", principal)

    @property
    @pulumi.getter
    def actions(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        <p>The IAM action to grant or revoke permissions on.</p>
        """
        return pulumi.get(self, "actions")

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

    @property
    @pulumi.getter
    def principal(self) -> pulumi.Input[str]:
        """
        <p>The Amazon Resource Name (ARN) of the principal. This can be one of the
                    following:</p>
                <ul>
                    <li>
                        <p>The ARN of an Amazon QuickSight user or group associated with a data source or dataset. (This is common.)</p>
                    </li>
                    <li>
                        <p>The ARN of an Amazon QuickSight user, group, or namespace associated with an analysis, dashboard, template, or theme. (This is common.)</p>
                    </li>
                    <li>
                        <p>The ARN of an AWS account root: This is an IAM ARN rather than a QuickSight
                            ARN. Use this option only to share resources (templates) across AWS accounts.
                            (This is less common.) </p>
                    </li>
                 </ul>
        """
        return pulumi.get(self, "principal")

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


@pulumi.input_type
class DashboardSheetControlsOptionArgs:
    def __init__(__self__, *,
                 visibility_state: Optional[pulumi.Input['DashboardDashboardUIState']] = None):
        """
        <p>Sheet controls option.</p>
        """
        if visibility_state is not None:
            pulumi.set(__self__, "visibility_state", visibility_state)

    @property
    @pulumi.getter(name="visibilityState")
    def visibility_state(self) -> Optional[pulumi.Input['DashboardDashboardUIState']]:
        return pulumi.get(self, "visibility_state")

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


@pulumi.input_type
class DashboardStringParameterArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 values: pulumi.Input[Sequence[pulumi.Input[str]]]):
        """
        <p>A string parameter.</p>
        :param pulumi.Input[str] name: <p>A display name for a string parameter.</p>
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: <p>The values of a string parameter.</p>
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        <p>A display name for a string parameter.</p>
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def values(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        <p>The values of a string parameter.</p>
        """
        return pulumi.get(self, "values")

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


@pulumi.input_type
class DashboardTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        <p>The key or keys of the key-value pairs for the resource tag or tags assigned to the
                    resource.</p>
        :param pulumi.Input[str] key: <p>Tag key.</p>
        :param pulumi.Input[str] value: <p>Tag value.</p>
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        <p>Tag key.</p>
        """
        return pulumi.get(self, "key")

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

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        <p>Tag value.</p>
        """
        return pulumi.get(self, "value")

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


@pulumi.input_type
class DataSetColumnGroupArgs:
    def __init__(__self__, *,
                 geo_spatial_column_group: Optional[pulumi.Input['DataSetGeoSpatialColumnGroupArgs']] = None):
        """
        <p>Groupings of columns that work together in certain Amazon QuickSight features. This is
                    a variant type structure. For this structure to be valid, only one of the attributes can
                    be non-null.</p>
        """
        if geo_spatial_column_group is not None:
            pulumi.set(__self__, "geo_spatial_column_group", geo_spatial_column_group)

    @property
    @pulumi.getter(name="geoSpatialColumnGroup")
    def geo_spatial_column_group(self) -> Optional[pulumi.Input['DataSetGeoSpatialColumnGroupArgs']]:
        return pulumi.get(self, "geo_spatial_column_group")

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


@pulumi.input_type
class DataSetColumnLevelPermissionRuleArgs:
    def __init__(__self__, *,
                 column_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 principals: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        if column_names is not None:
            pulumi.set(__self__, "column_names", column_names)
        if principals is not None:
            pulumi.set(__self__, "principals", principals)

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

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

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

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


@pulumi.input_type
class DataSetFieldFolderMapArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class DataSetGeoSpatialColumnGroupArgs:
    def __init__(__self__, *,
                 columns: pulumi.Input[Sequence[pulumi.Input[str]]],
                 name: pulumi.Input[str],
                 country_code: Optional[pulumi.Input['DataSetGeoSpatialCountryCode']] = None):
        """
        <p>Geospatial column group that denotes a hierarchy.</p>
        :param pulumi.Input[Sequence[pulumi.Input[str]]] columns: <p>Columns in this hierarchy.</p>
        :param pulumi.Input[str] name: <p>A display name for the hierarchy.</p>
        """
        pulumi.set(__self__, "columns", columns)
        pulumi.set(__self__, "name", name)
        if country_code is not None:
            pulumi.set(__self__, "country_code", country_code)

    @property
    @pulumi.getter
    def columns(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        <p>Columns in this hierarchy.</p>
        """
        return pulumi.get(self, "columns")

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

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        <p>A display name for the hierarchy.</p>
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter(name="countryCode")
    def country_code(self) -> Optional[pulumi.Input['DataSetGeoSpatialCountryCode']]:
        return pulumi.get(self, "country_code")

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


@pulumi.input_type
class DataSetIngestionWaitPolicyArgs:
    def __init__(__self__, *,
                 ingestion_wait_time_in_hours: Optional[pulumi.Input[float]] = None,
                 wait_for_spice_ingestion: Optional[pulumi.Input[bool]] = None):
        """
        <p>Wait policy to use when creating/updating dataset. Default is to wait for SPICE ingestion to finish with timeout of 36 hours.</p>
        :param pulumi.Input[float] ingestion_wait_time_in_hours: <p>The maximum time (in hours) to wait for Ingestion to complete. Default timeout is 36 hours.
                Applicable only when DataSetImportMode mode is set to SPICE and WaitForSpiceIngestion is set to true.</p>
        :param pulumi.Input[bool] wait_for_spice_ingestion: <p>Wait for SPICE ingestion to finish to mark dataset creation/update successful. Default (true).
                 Applicable only when DataSetImportMode mode is set to SPICE.</p>
        """
        if ingestion_wait_time_in_hours is not None:
            pulumi.set(__self__, "ingestion_wait_time_in_hours", ingestion_wait_time_in_hours)
        if wait_for_spice_ingestion is not None:
            pulumi.set(__self__, "wait_for_spice_ingestion", wait_for_spice_ingestion)

    @property
    @pulumi.getter(name="ingestionWaitTimeInHours")
    def ingestion_wait_time_in_hours(self) -> Optional[pulumi.Input[float]]:
        """
        <p>The maximum time (in hours) to wait for Ingestion to complete. Default timeout is 36 hours.
         Applicable only when DataSetImportMode mode is set to SPICE and WaitForSpiceIngestion is set to true.</p>
        """
        return pulumi.get(self, "ingestion_wait_time_in_hours")

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

    @property
    @pulumi.getter(name="waitForSpiceIngestion")
    def wait_for_spice_ingestion(self) -> Optional[pulumi.Input[bool]]:
        """
        <p>Wait for SPICE ingestion to finish to mark dataset creation/update successful. Default (true).
          Applicable only when DataSetImportMode mode is set to SPICE.</p>
        """
        return pulumi.get(self, "wait_for_spice_ingestion")

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


@pulumi.input_type
class DataSetLogicalTableMapArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class DataSetPhysicalTableMapArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class DataSetResourcePermissionArgs:
    def __init__(__self__, *,
                 actions: pulumi.Input[Sequence[pulumi.Input[str]]],
                 principal: pulumi.Input[str]):
        """
        <p>Permission for the resource.</p>
        :param pulumi.Input[Sequence[pulumi.Input[str]]] actions: <p>The IAM action to grant or revoke permissions on.</p>
        :param pulumi.Input[str] principal: <p>The Amazon Resource Name (ARN) of the principal. This can be one of the
                           following:</p>
                       <ul>
                           <li>
                               <p>The ARN of an Amazon QuickSight user or group associated with a data source or dataset. (This is common.)</p>
                           </li>
                           <li>
                               <p>The ARN of an Amazon QuickSight user, group, or namespace associated with an analysis, dashboard, template, or theme. (This is common.)</p>
                           </li>
                           <li>
                               <p>The ARN of an AWS account root: This is an IAM ARN rather than a QuickSight
                                   ARN. Use this option only to share resources (templates) across AWS accounts.
                                   (This is less common.) </p>
                           </li>
                        </ul>
        """
        pulumi.set(__self__, "actions", actions)
        pulumi.set(__self__, "principal", principal)

    @property
    @pulumi.getter
    def actions(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        <p>The IAM action to grant or revoke permissions on.</p>
        """
        return pulumi.get(self, "actions")

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

    @property
    @pulumi.getter
    def principal(self) -> pulumi.Input[str]:
        """
        <p>The Amazon Resource Name (ARN) of the principal. This can be one of the
                    following:</p>
                <ul>
                    <li>
                        <p>The ARN of an Amazon QuickSight user or group associated with a data source or dataset. (This is common.)</p>
                    </li>
                    <li>
                        <p>The ARN of an Amazon QuickSight user, group, or namespace associated with an analysis, dashboard, template, or theme. (This is common.)</p>
                    </li>
                    <li>
                        <p>The ARN of an AWS account root: This is an IAM ARN rather than a QuickSight
                            ARN. Use this option only to share resources (templates) across AWS accounts.
                            (This is less common.) </p>
                    </li>
                 </ul>
        """
        return pulumi.get(self, "principal")

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


@pulumi.input_type
class DataSetRowLevelPermissionDataSetArgs:
    def __init__(__self__, *,
                 arn: pulumi.Input[str],
                 permission_policy: pulumi.Input['DataSetRowLevelPermissionPolicy'],
                 format_version: Optional[pulumi.Input['DataSetRowLevelPermissionFormatVersion']] = None,
                 namespace: Optional[pulumi.Input[str]] = None):
        """
        <p>The row-level security configuration for the dataset.</p>
        :param pulumi.Input[str] arn: <p>The Amazon Resource Name (ARN) of the permission dataset.</p>
        :param pulumi.Input[str] namespace: <p>The namespace associated with the row-level permissions dataset.</p>
        """
        pulumi.set(__self__, "arn", arn)
        pulumi.set(__self__, "permission_policy", permission_policy)
        if format_version is not None:
            pulumi.set(__self__, "format_version", format_version)
        if namespace is not None:
            pulumi.set(__self__, "namespace", namespace)

    @property
    @pulumi.getter
    def arn(self) -> pulumi.Input[str]:
        """
        <p>The Amazon Resource Name (ARN) of the permission dataset.</p>
        """
        return pulumi.get(self, "arn")

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

    @property
    @pulumi.getter(name="permissionPolicy")
    def permission_policy(self) -> pulumi.Input['DataSetRowLevelPermissionPolicy']:
        return pulumi.get(self, "permission_policy")

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

    @property
    @pulumi.getter(name="formatVersion")
    def format_version(self) -> Optional[pulumi.Input['DataSetRowLevelPermissionFormatVersion']]:
        return pulumi.get(self, "format_version")

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

    @property
    @pulumi.getter
    def namespace(self) -> Optional[pulumi.Input[str]]:
        """
        <p>The namespace associated with the row-level permissions dataset.</p>
        """
        return pulumi.get(self, "namespace")

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


@pulumi.input_type
class DataSetTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        <p>The key or keys of the key-value pairs for the resource tag or tags assigned to the
                    resource.</p>
        :param pulumi.Input[str] key: <p>Tag key.</p>
        :param pulumi.Input[str] value: <p>Tag value.</p>
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        <p>Tag key.</p>
        """
        return pulumi.get(self, "key")

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

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        <p>Tag value.</p>
        """
        return pulumi.get(self, "value")

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


@pulumi.input_type
class DataSourceAmazonElasticsearchParametersArgs:
    def __init__(__self__, *,
                 domain: pulumi.Input[str]):
        """
        <p>Amazon Elasticsearch Service parameters.</p>
        :param pulumi.Input[str] domain: <p>The Amazon Elasticsearch Service domain.</p>
        """
        pulumi.set(__self__, "domain", domain)

    @property
    @pulumi.getter
    def domain(self) -> pulumi.Input[str]:
        """
        <p>The Amazon Elasticsearch Service domain.</p>
        """
        return pulumi.get(self, "domain")

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


@pulumi.input_type
class DataSourceAthenaParametersArgs:
    def __init__(__self__, *,
                 work_group: Optional[pulumi.Input[str]] = None):
        """
        <p>Amazon Athena parameters.</p>
        :param pulumi.Input[str] work_group: <p>The workgroup that Amazon Athena uses.</p>
        """
        if work_group is not None:
            pulumi.set(__self__, "work_group", work_group)

    @property
    @pulumi.getter(name="workGroup")
    def work_group(self) -> Optional[pulumi.Input[str]]:
        """
        <p>The workgroup that Amazon Athena uses.</p>
        """
        return pulumi.get(self, "work_group")

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


@pulumi.input_type
class DataSourceAuroraParametersArgs:
    def __init__(__self__, *,
                 database: pulumi.Input[str],
                 host: pulumi.Input[str],
                 port: pulumi.Input[float]):
        """
        <p>Amazon Aurora parameters.</p>
        :param pulumi.Input[str] database: <p>Database.</p>
        :param pulumi.Input[str] host: <p>Host.</p>
        :param pulumi.Input[float] port: <p>Port.</p>
        """
        pulumi.set(__self__, "database", database)
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def database(self) -> pulumi.Input[str]:
        """
        <p>Database.</p>
        """
        return pulumi.get(self, "database")

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

    @property
    @pulumi.getter
    def host(self) -> pulumi.Input[str]:
        """
        <p>Host.</p>
        """
        return pulumi.get(self, "host")

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

    @property
    @pulumi.getter
    def port(self) -> pulumi.Input[float]:
        """
        <p>Port.</p>
        """
        return pulumi.get(self, "port")

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


@pulumi.input_type
class DataSourceAuroraPostgreSqlParametersArgs:
    def __init__(__self__, *,
                 database: pulumi.Input[str],
                 host: pulumi.Input[str],
                 port: pulumi.Input[float]):
        """
        <p>Amazon Aurora with PostgreSQL compatibility parameters.</p>
        :param pulumi.Input[str] database: <p>Database.</p>
        :param pulumi.Input[str] host: <p>Host.</p>
        :param pulumi.Input[float] port: <p>Port.</p>
        """
        pulumi.set(__self__, "database", database)
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def database(self) -> pulumi.Input[str]:
        """
        <p>Database.</p>
        """
        return pulumi.get(self, "database")

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

    @property
    @pulumi.getter
    def host(self) -> pulumi.Input[str]:
        """
        <p>Host.</p>
        """
        return pulumi.get(self, "host")

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

    @property
    @pulumi.getter
    def port(self) -> pulumi.Input[float]:
        """
        <p>Port.</p>
        """
        return pulumi.get(self, "port")

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


@pulumi.input_type
class DataSourceCredentialPairArgs:
    def __init__(__self__, *,
                 password: pulumi.Input[str],
                 username: pulumi.Input[str],
                 alternate_data_source_parameters: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceParametersArgs']]]] = None):
        """
        <p>The combination of user name and password that are used as credentials.</p>
        :param pulumi.Input[str] password: <p>Password.</p>
        :param pulumi.Input[str] username: <p>User name.</p>
        :param pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceParametersArgs']]] alternate_data_source_parameters: <p>A set of alternate data source parameters that you want to share for these
                           credentials. The credentials are applied in tandem with the data source parameters when
                           you copy a data source by using a create or update request. The API operation compares
                           the <code>DataSourceParameters</code> structure that's in the request with the
                           structures in the <code>AlternateDataSourceParameters</code> allow list. If the
                           structures are an exact match, the request is allowed to use the new data source with
                           the existing credentials. If the <code>AlternateDataSourceParameters</code> list is
                           null, the <code>DataSourceParameters</code> originally used with these
                               <code>Credentials</code> is automatically allowed.</p>
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)
        if alternate_data_source_parameters is not None:
            pulumi.set(__self__, "alternate_data_source_parameters", alternate_data_source_parameters)

    @property
    @pulumi.getter
    def password(self) -> pulumi.Input[str]:
        """
        <p>Password.</p>
        """
        return pulumi.get(self, "password")

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

    @property
    @pulumi.getter
    def username(self) -> pulumi.Input[str]:
        """
        <p>User name.</p>
        """
        return pulumi.get(self, "username")

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

    @property
    @pulumi.getter(name="alternateDataSourceParameters")
    def alternate_data_source_parameters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceParametersArgs']]]]:
        """
        <p>A set of alternate data source parameters that you want to share for these
                    credentials. The credentials are applied in tandem with the data source parameters when
                    you copy a data source by using a create or update request. The API operation compares
                    the <code>DataSourceParameters</code> structure that's in the request with the
                    structures in the <code>AlternateDataSourceParameters</code> allow list. If the
                    structures are an exact match, the request is allowed to use the new data source with
                    the existing credentials. If the <code>AlternateDataSourceParameters</code> list is
                    null, the <code>DataSourceParameters</code> originally used with these
                        <code>Credentials</code> is automatically allowed.</p>
        """
        return pulumi.get(self, "alternate_data_source_parameters")

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


@pulumi.input_type
class DataSourceDataSourceCredentialsArgs:
    def __init__(__self__, *,
                 copy_source_arn: Optional[pulumi.Input[str]] = None,
                 credential_pair: Optional[pulumi.Input['DataSourceCredentialPairArgs']] = None):
        """
        <p>Data source credentials. This is a variant type structure. For this structure to be
                    valid, only one of the attributes can be non-null.</p>
        :param pulumi.Input[str] copy_source_arn: <p>The Amazon Resource Name (ARN) of a data source that has the credential pair that you
                           want to use. When <code>CopySourceArn</code> is not null, the credential pair from the
                           data source in the ARN is used as the credentials for the
                           <code>DataSourceCredentials</code> structure.</p>
        """
        if copy_source_arn is not None:
            pulumi.set(__self__, "copy_source_arn", copy_source_arn)
        if credential_pair is not None:
            pulumi.set(__self__, "credential_pair", credential_pair)

    @property
    @pulumi.getter(name="copySourceArn")
    def copy_source_arn(self) -> Optional[pulumi.Input[str]]:
        """
        <p>The Amazon Resource Name (ARN) of a data source that has the credential pair that you
                    want to use. When <code>CopySourceArn</code> is not null, the credential pair from the
                    data source in the ARN is used as the credentials for the
                    <code>DataSourceCredentials</code> structure.</p>
        """
        return pulumi.get(self, "copy_source_arn")

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

    @property
    @pulumi.getter(name="credentialPair")
    def credential_pair(self) -> Optional[pulumi.Input['DataSourceCredentialPairArgs']]:
        return pulumi.get(self, "credential_pair")

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


@pulumi.input_type
class DataSourceDataSourceErrorInfoArgs:
    def __init__(__self__, *,
                 message: Optional[pulumi.Input[str]] = None,
                 type: Optional[pulumi.Input['DataSourceDataSourceErrorInfoType']] = None):
        """
        <p>Error information for the data source creation or update.</p>
        :param pulumi.Input[str] message: <p>Error message.</p>
        """
        if message is not None:
            pulumi.set(__self__, "message", message)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def message(self) -> Optional[pulumi.Input[str]]:
        """
        <p>Error message.</p>
        """
        return pulumi.get(self, "message")

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

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input['DataSourceDataSourceErrorInfoType']]:
        return pulumi.get(self, "type")

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


@pulumi.input_type
class DataSourceDataSourceParametersArgs:
    def __init__(__self__, *,
                 amazon_elasticsearch_parameters: Optional[pulumi.Input['DataSourceAmazonElasticsearchParametersArgs']] = None,
                 athena_parameters: Optional[pulumi.Input['DataSourceAthenaParametersArgs']] = None,
                 aurora_parameters: Optional[pulumi.Input['DataSourceAuroraParametersArgs']] = None,
                 aurora_postgre_sql_parameters: Optional[pulumi.Input['DataSourceAuroraPostgreSqlParametersArgs']] = None,
                 maria_db_parameters: Optional[pulumi.Input['DataSourceMariaDbParametersArgs']] = None,
                 my_sql_parameters: Optional[pulumi.Input['DataSourceMySqlParametersArgs']] = None,
                 oracle_parameters: Optional[pulumi.Input['DataSourceOracleParametersArgs']] = None,
                 postgre_sql_parameters: Optional[pulumi.Input['DataSourcePostgreSqlParametersArgs']] = None,
                 presto_parameters: Optional[pulumi.Input['DataSourcePrestoParametersArgs']] = None,
                 rds_parameters: Optional[pulumi.Input['DataSourceRdsParametersArgs']] = None,
                 redshift_parameters: Optional[pulumi.Input['DataSourceRedshiftParametersArgs']] = None,
                 s3_parameters: Optional[pulumi.Input['DataSourceS3ParametersArgs']] = None,
                 snowflake_parameters: Optional[pulumi.Input['DataSourceSnowflakeParametersArgs']] = None,
                 spark_parameters: Optional[pulumi.Input['DataSourceSparkParametersArgs']] = None,
                 sql_server_parameters: Optional[pulumi.Input['DataSourceSqlServerParametersArgs']] = None,
                 teradata_parameters: Optional[pulumi.Input['DataSourceTeradataParametersArgs']] = None):
        """
        <p>The parameters that Amazon QuickSight uses to connect to your underlying data source.
                    This is a variant type structure. For this structure to be valid, only one of the
                    attributes can be non-null.</p>
        """
        if amazon_elasticsearch_parameters is not None:
            pulumi.set(__self__, "amazon_elasticsearch_parameters", amazon_elasticsearch_parameters)
        if athena_parameters is not None:
            pulumi.set(__self__, "athena_parameters", athena_parameters)
        if aurora_parameters is not None:
            pulumi.set(__self__, "aurora_parameters", aurora_parameters)
        if aurora_postgre_sql_parameters is not None:
            pulumi.set(__self__, "aurora_postgre_sql_parameters", aurora_postgre_sql_parameters)
        if maria_db_parameters is not None:
            pulumi.set(__self__, "maria_db_parameters", maria_db_parameters)
        if my_sql_parameters is not None:
            pulumi.set(__self__, "my_sql_parameters", my_sql_parameters)
        if oracle_parameters is not None:
            pulumi.set(__self__, "oracle_parameters", oracle_parameters)
        if postgre_sql_parameters is not None:
            pulumi.set(__self__, "postgre_sql_parameters", postgre_sql_parameters)
        if presto_parameters is not None:
            pulumi.set(__self__, "presto_parameters", presto_parameters)
        if rds_parameters is not None:
            pulumi.set(__self__, "rds_parameters", rds_parameters)
        if redshift_parameters is not None:
            pulumi.set(__self__, "redshift_parameters", redshift_parameters)
        if s3_parameters is not None:
            pulumi.set(__self__, "s3_parameters", s3_parameters)
        if snowflake_parameters is not None:
            pulumi.set(__self__, "snowflake_parameters", snowflake_parameters)
        if spark_parameters is not None:
            pulumi.set(__self__, "spark_parameters", spark_parameters)
        if sql_server_parameters is not None:
            pulumi.set(__self__, "sql_server_parameters", sql_server_parameters)
        if teradata_parameters is not None:
            pulumi.set(__self__, "teradata_parameters", teradata_parameters)

    @property
    @pulumi.getter(name="amazonElasticsearchParameters")
    def amazon_elasticsearch_parameters(self) -> Optional[pulumi.Input['DataSourceAmazonElasticsearchParametersArgs']]:
        return pulumi.get(self, "amazon_elasticsearch_parameters")

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

    @property
    @pulumi.getter(name="athenaParameters")
    def athena_parameters(self) -> Optional[pulumi.Input['DataSourceAthenaParametersArgs']]:
        return pulumi.get(self, "athena_parameters")

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

    @property
    @pulumi.getter(name="auroraParameters")
    def aurora_parameters(self) -> Optional[pulumi.Input['DataSourceAuroraParametersArgs']]:
        return pulumi.get(self, "aurora_parameters")

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

    @property
    @pulumi.getter(name="auroraPostgreSqlParameters")
    def aurora_postgre_sql_parameters(self) -> Optional[pulumi.Input['DataSourceAuroraPostgreSqlParametersArgs']]:
        return pulumi.get(self, "aurora_postgre_sql_parameters")

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

    @property
    @pulumi.getter(name="mariaDbParameters")
    def maria_db_parameters(self) -> Optional[pulumi.Input['DataSourceMariaDbParametersArgs']]:
        return pulumi.get(self, "maria_db_parameters")

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

    @property
    @pulumi.getter(name="mySqlParameters")
    def my_sql_parameters(self) -> Optional[pulumi.Input['DataSourceMySqlParametersArgs']]:
        return pulumi.get(self, "my_sql_parameters")

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

    @property
    @pulumi.getter(name="oracleParameters")
    def oracle_parameters(self) -> Optional[pulumi.Input['DataSourceOracleParametersArgs']]:
        return pulumi.get(self, "oracle_parameters")

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

    @property
    @pulumi.getter(name="postgreSqlParameters")
    def postgre_sql_parameters(self) -> Optional[pulumi.Input['DataSourcePostgreSqlParametersArgs']]:
        return pulumi.get(self, "postgre_sql_parameters")

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

    @property
    @pulumi.getter(name="prestoParameters")
    def presto_parameters(self) -> Optional[pulumi.Input['DataSourcePrestoParametersArgs']]:
        return pulumi.get(self, "presto_parameters")

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

    @property
    @pulumi.getter(name="rdsParameters")
    def rds_parameters(self) -> Optional[pulumi.Input['DataSourceRdsParametersArgs']]:
        return pulumi.get(self, "rds_parameters")

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

    @property
    @pulumi.getter(name="redshiftParameters")
    def redshift_parameters(self) -> Optional[pulumi.Input['DataSourceRedshiftParametersArgs']]:
        return pulumi.get(self, "redshift_parameters")

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

    @property
    @pulumi.getter(name="s3Parameters")
    def s3_parameters(self) -> Optional[pulumi.Input['DataSourceS3ParametersArgs']]:
        return pulumi.get(self, "s3_parameters")

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

    @property
    @pulumi.getter(name="snowflakeParameters")
    def snowflake_parameters(self) -> Optional[pulumi.Input['DataSourceSnowflakeParametersArgs']]:
        return pulumi.get(self, "snowflake_parameters")

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

    @property
    @pulumi.getter(name="sparkParameters")
    def spark_parameters(self) -> Optional[pulumi.Input['DataSourceSparkParametersArgs']]:
        return pulumi.get(self, "spark_parameters")

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

    @property
    @pulumi.getter(name="sqlServerParameters")
    def sql_server_parameters(self) -> Optional[pulumi.Input['DataSourceSqlServerParametersArgs']]:
        return pulumi.get(self, "sql_server_parameters")

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

    @property
    @pulumi.getter(name="teradataParameters")
    def teradata_parameters(self) -> Optional[pulumi.Input['DataSourceTeradataParametersArgs']]:
        return pulumi.get(self, "teradata_parameters")

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


@pulumi.input_type
class DataSourceManifestFileLocationArgs:
    def __init__(__self__, *,
                 bucket: pulumi.Input[str],
                 key: pulumi.Input[str]):
        """
        <p>Amazon S3 manifest file location.</p>
        :param pulumi.Input[str] bucket: <p>Amazon S3 bucket.</p>
        :param pulumi.Input[str] key: <p>Amazon S3 key that identifies an object.</p>
        """
        pulumi.set(__self__, "bucket", bucket)
        pulumi.set(__self__, "key", key)

    @property
    @pulumi.getter
    def bucket(self) -> pulumi.Input[str]:
        """
        <p>Amazon S3 bucket.</p>
        """
        return pulumi.get(self, "bucket")

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

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        <p>Amazon S3 key that identifies an object.</p>
        """
        return pulumi.get(self, "key")

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


@pulumi.input_type
class DataSourceMariaDbParametersArgs:
    def __init__(__self__, *,
                 database: pulumi.Input[str],
                 host: pulumi.Input[str],
                 port: pulumi.Input[float]):
        """
        <p>MariaDB parameters.</p>
        :param pulumi.Input[str] database: <p>Database.</p>
        :param pulumi.Input[str] host: <p>Host.</p>
        :param pulumi.Input[float] port: <p>Port.</p>
        """
        pulumi.set(__self__, "database", database)
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def database(self) -> pulumi.Input[str]:
        """
        <p>Database.</p>
        """
        return pulumi.get(self, "database")

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

    @property
    @pulumi.getter
    def host(self) -> pulumi.Input[str]:
        """
        <p>Host.</p>
        """
        return pulumi.get(self, "host")

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

    @property
    @pulumi.getter
    def port(self) -> pulumi.Input[float]:
        """
        <p>Port.</p>
        """
        return pulumi.get(self, "port")

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


@pulumi.input_type
class DataSourceMySqlParametersArgs:
    def __init__(__self__, *,
                 database: pulumi.Input[str],
                 host: pulumi.Input[str],
                 port: pulumi.Input[float]):
        """
        <p>MySQL parameters.</p>
        :param pulumi.Input[str] database: <p>Database.</p>
        :param pulumi.Input[str] host: <p>Host.</p>
        :param pulumi.Input[float] port: <p>Port.</p>
        """
        pulumi.set(__self__, "database", database)
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def database(self) -> pulumi.Input[str]:
        """
        <p>Database.</p>
        """
        return pulumi.get(self, "database")

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

    @property
    @pulumi.getter
    def host(self) -> pulumi.Input[str]:
        """
        <p>Host.</p>
        """
        return pulumi.get(self, "host")

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

    @property
    @pulumi.getter
    def port(self) -> pulumi.Input[float]:
        """
        <p>Port.</p>
        """
        return pulumi.get(self, "port")

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


@pulumi.input_type
class DataSourceOracleParametersArgs:
    def __init__(__self__, *,
                 database: pulumi.Input[str],
                 host: pulumi.Input[str],
                 port: pulumi.Input[float]):
        pulumi.set(__self__, "database", database)
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)

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

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

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

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

    @property
    @pulumi.getter
    def port(self) -> pulumi.Input[float]:
        return pulumi.get(self, "port")

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


@pulumi.input_type
class DataSourcePostgreSqlParametersArgs:
    def __init__(__self__, *,
                 database: pulumi.Input[str],
                 host: pulumi.Input[str],
                 port: pulumi.Input[float]):
        """
        <p>PostgreSQL parameters.</p>
        :param pulumi.Input[str] database: <p>Database.</p>
        :param pulumi.Input[str] host: <p>Host.</p>
        :param pulumi.Input[float] port: <p>Port.</p>
        """
        pulumi.set(__self__, "database", database)
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def database(self) -> pulumi.Input[str]:
        """
        <p>Database.</p>
        """
        return pulumi.get(self, "database")

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

    @property
    @pulumi.getter
    def host(self) -> pulumi.Input[str]:
        """
        <p>Host.</p>
        """
        return pulumi.get(self, "host")

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

    @property
    @pulumi.getter
    def port(self) -> pulumi.Input[float]:
        """
        <p>Port.</p>
        """
        return pulumi.get(self, "port")

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


@pulumi.input_type
class DataSourcePrestoParametersArgs:
    def __init__(__self__, *,
                 catalog: pulumi.Input[str],
                 host: pulumi.Input[str],
                 port: pulumi.Input[float]):
        """
        <p>Presto parameters.</p>
        :param pulumi.Input[str] catalog: <p>Catalog.</p>
        :param pulumi.Input[str] host: <p>Host.</p>
        :param pulumi.Input[float] port: <p>Port.</p>
        """
        pulumi.set(__self__, "catalog", catalog)
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def catalog(self) -> pulumi.Input[str]:
        """
        <p>Catalog.</p>
        """
        return pulumi.get(self, "catalog")

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

    @property
    @pulumi.getter
    def host(self) -> pulumi.Input[str]:
        """
        <p>Host.</p>
        """
        return pulumi.get(self, "host")

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

    @property
    @pulumi.getter
    def port(self) -> pulumi.Input[float]:
        """
        <p>Port.</p>
        """
        return pulumi.get(self, "port")

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


@pulumi.input_type
class DataSourceRdsParametersArgs:
    def __init__(__self__, *,
                 database: pulumi.Input[str],
                 instance_id: pulumi.Input[str]):
        """
        <p>Amazon RDS parameters.</p>
        :param pulumi.Input[str] database: <p>Database.</p>
        :param pulumi.Input[str] instance_id: <p>Instance ID.</p>
        """
        pulumi.set(__self__, "database", database)
        pulumi.set(__self__, "instance_id", instance_id)

    @property
    @pulumi.getter
    def database(self) -> pulumi.Input[str]:
        """
        <p>Database.</p>
        """
        return pulumi.get(self, "database")

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

    @property
    @pulumi.getter(name="instanceId")
    def instance_id(self) -> pulumi.Input[str]:
        """
        <p>Instance ID.</p>
        """
        return pulumi.get(self, "instance_id")

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


@pulumi.input_type
class DataSourceRedshiftParametersArgs:
    def __init__(__self__, *,
                 database: pulumi.Input[str],
                 cluster_id: Optional[pulumi.Input[str]] = None,
                 host: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[float]] = None):
        """
        <p>Amazon Redshift parameters. The <code>ClusterId</code> field can be blank if
                    <code>Host</code> and <code>Port</code> are both set. The <code>Host</code> and
                    <code>Port</code> fields can be blank if the <code>ClusterId</code> field is set.</p>
        :param pulumi.Input[str] database: <p>Database.</p>
        :param pulumi.Input[str] cluster_id: <p>Cluster ID. This field can be blank if the <code>Host</code> and <code>Port</code> are
                           provided.</p>
        :param pulumi.Input[str] host: <p>Host. This field can be blank if <code>ClusterId</code> is provided.</p>
        :param pulumi.Input[float] port: <p>Port. This field can be blank if the <code>ClusterId</code> is provided.</p>
        """
        pulumi.set(__self__, "database", database)
        if cluster_id is not None:
            pulumi.set(__self__, "cluster_id", cluster_id)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if port is not None:
            pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def database(self) -> pulumi.Input[str]:
        """
        <p>Database.</p>
        """
        return pulumi.get(self, "database")

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

    @property
    @pulumi.getter(name="clusterId")
    def cluster_id(self) -> Optional[pulumi.Input[str]]:
        """
        <p>Cluster ID. This field can be blank if the <code>Host</code> and <code>Port</code> are
                    provided.</p>
        """
        return pulumi.get(self, "cluster_id")

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

    @property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[str]]:
        """
        <p>Host. This field can be blank if <code>ClusterId</code> is provided.</p>
        """
        return pulumi.get(self, "host")

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

    @property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[float]]:
        """
        <p>Port. This field can be blank if the <code>ClusterId</code> is provided.</p>
        """
        return pulumi.get(self, "port")

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


@pulumi.input_type
class DataSourceResourcePermissionArgs:
    def __init__(__self__, *,
                 actions: pulumi.Input[Sequence[pulumi.Input[str]]],
                 principal: pulumi.Input[str]):
        """
        <p>Permission for the resource.</p>
        :param pulumi.Input[Sequence[pulumi.Input[str]]] actions: <p>The IAM action to grant or revoke permissions on.</p>
        :param pulumi.Input[str] principal: <p>The Amazon Resource Name (ARN) of the principal. This can be one of the
                           following:</p>
                       <ul>
                           <li>
                               <p>The ARN of an Amazon QuickSight user or group associated with a data source or dataset. (This is common.)</p>
                           </li>
                           <li>
                               <p>The ARN of an Amazon QuickSight user, group, or namespace associated with an analysis, dashboard, template, or theme. (This is common.)</p>
                           </li>
                           <li>
                               <p>The ARN of an AWS account root: This is an IAM ARN rather than a QuickSight
                                   ARN. Use this option only to share resources (templates) across AWS accounts.
                                   (This is less common.) </p>
                           </li>
                        </ul>
        """
        pulumi.set(__self__, "actions", actions)
        pulumi.set(__self__, "principal", principal)

    @property
    @pulumi.getter
    def actions(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        <p>The IAM action to grant or revoke permissions on.</p>
        """
        return pulumi.get(self, "actions")

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

    @property
    @pulumi.getter
    def principal(self) -> pulumi.Input[str]:
        """
        <p>The Amazon Resource Name (ARN) of the principal. This can be one of the
                    following:</p>
                <ul>
                    <li>
                        <p>The ARN of an Amazon QuickSight user or group associated with a data source or dataset. (This is common.)</p>
                    </li>
                    <li>
                        <p>The ARN of an Amazon QuickSight user, group, or namespace associated with an analysis, dashboard, template, or theme. (This is common.)</p>
                    </li>
                    <li>
                        <p>The ARN of an AWS account root: This is an IAM ARN rather than a QuickSight
                            ARN. Use this option only to share resources (templates) across AWS accounts.
                            (This is less common.) </p>
                    </li>
                 </ul>
        """
        return pulumi.get(self, "principal")

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


@pulumi.input_type
class DataSourceS3ParametersArgs:
    def __init__(__self__, *,
                 manifest_file_location: pulumi.Input['DataSourceManifestFileLocationArgs']):
        """
        <p>S3 parameters.</p>
        """
        pulumi.set(__self__, "manifest_file_location", manifest_file_location)

    @property
    @pulumi.getter(name="manifestFileLocation")
    def manifest_file_location(self) -> pulumi.Input['DataSourceManifestFileLocationArgs']:
        return pulumi.get(self, "manifest_file_location")

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


@pulumi.input_type
class DataSourceSnowflakeParametersArgs:
    def __init__(__self__, *,
                 database: pulumi.Input[str],
                 host: pulumi.Input[str],
                 warehouse: pulumi.Input[str]):
        """
        <p>Snowflake parameters.</p>
        :param pulumi.Input[str] database: <p>Database.</p>
        :param pulumi.Input[str] host: <p>Host.</p>
        :param pulumi.Input[str] warehouse: <p>Warehouse.</p>
        """
        pulumi.set(__self__, "database", database)
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "warehouse", warehouse)

    @property
    @pulumi.getter
    def database(self) -> pulumi.Input[str]:
        """
        <p>Database.</p>
        """
        return pulumi.get(self, "database")

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

    @property
    @pulumi.getter
    def host(self) -> pulumi.Input[str]:
        """
        <p>Host.</p>
        """
        return pulumi.get(self, "host")

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

    @property
    @pulumi.getter
    def warehouse(self) -> pulumi.Input[str]:
        """
        <p>Warehouse.</p>
        """
        return pulumi.get(self, "warehouse")

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


@pulumi.input_type
class DataSourceSparkParametersArgs:
    def __init__(__self__, *,
                 host: pulumi.Input[str],
                 port: pulumi.Input[float]):
        """
        <p>Spark parameters.</p>
        :param pulumi.Input[str] host: <p>Host.</p>
        :param pulumi.Input[float] port: <p>Port.</p>
        """
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def host(self) -> pulumi.Input[str]:
        """
        <p>Host.</p>
        """
        return pulumi.get(self, "host")

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

    @property
    @pulumi.getter
    def port(self) -> pulumi.Input[float]:
        """
        <p>Port.</p>
        """
        return pulumi.get(self, "port")

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


@pulumi.input_type
class DataSourceSqlServerParametersArgs:
    def __init__(__self__, *,
                 database: pulumi.Input[str],
                 host: pulumi.Input[str],
                 port: pulumi.Input[float]):
        """
        <p>SQL Server parameters.</p>
        :param pulumi.Input[str] database: <p>Database.</p>
        :param pulumi.Input[str] host: <p>Host.</p>
        :param pulumi.Input[float] port: <p>Port.</p>
        """
        pulumi.set(__self__, "database", database)
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def database(self) -> pulumi.Input[str]:
        """
        <p>Database.</p>
        """
        return pulumi.get(self, "database")

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

    @property
    @pulumi.getter
    def host(self) -> pulumi.Input[str]:
        """
        <p>Host.</p>
        """
        return pulumi.get(self, "host")

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

    @property
    @pulumi.getter
    def port(self) -> pulumi.Input[float]:
        """
        <p>Port.</p>
        """
        return pulumi.get(self, "port")

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


@pulumi.input_type
class DataSourceSslPropertiesArgs:
    def __init__(__self__, *,
                 disable_ssl: Optional[pulumi.Input[bool]] = None):
        """
        <p>Secure Socket Layer (SSL) properties that apply when QuickSight connects to your
                    underlying data source.</p>
        :param pulumi.Input[bool] disable_ssl: <p>A Boolean option to control whether SSL should be disabled.</p>
        """
        if disable_ssl is not None:
            pulumi.set(__self__, "disable_ssl", disable_ssl)

    @property
    @pulumi.getter(name="disableSsl")
    def disable_ssl(self) -> Optional[pulumi.Input[bool]]:
        """
        <p>A Boolean option to control whether SSL should be disabled.</p>
        """
        return pulumi.get(self, "disable_ssl")

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


@pulumi.input_type
class DataSourceTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        <p>The key or keys of the key-value pairs for the resource tag or tags assigned to the
                    resource.</p>
        :param pulumi.Input[str] key: <p>Tag key.</p>
        :param pulumi.Input[str] value: <p>Tag value.</p>
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        <p>Tag key.</p>
        """
        return pulumi.get(self, "key")

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

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        <p>Tag value.</p>
        """
        return pulumi.get(self, "value")

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


@pulumi.input_type
class DataSourceTeradataParametersArgs:
    def __init__(__self__, *,
                 database: pulumi.Input[str],
                 host: pulumi.Input[str],
                 port: pulumi.Input[float]):
        """
        <p>Teradata parameters.</p>
        :param pulumi.Input[str] database: <p>Database.</p>
        :param pulumi.Input[str] host: <p>Host.</p>
        :param pulumi.Input[float] port: <p>Port.</p>
        """
        pulumi.set(__self__, "database", database)
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def database(self) -> pulumi.Input[str]:
        """
        <p>Database.</p>
        """
        return pulumi.get(self, "database")

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

    @property
    @pulumi.getter
    def host(self) -> pulumi.Input[str]:
        """
        <p>Host.</p>
        """
        return pulumi.get(self, "host")

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

    @property
    @pulumi.getter
    def port(self) -> pulumi.Input[float]:
        """
        <p>Port.</p>
        """
        return pulumi.get(self, "port")

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


@pulumi.input_type
class DataSourceVpcConnectionPropertiesArgs:
    def __init__(__self__, *,
                 vpc_connection_arn: pulumi.Input[str]):
        """
        <p>VPC connection properties.</p>
        :param pulumi.Input[str] vpc_connection_arn: <p>The Amazon Resource Name (ARN) for the VPC connection.</p>
        """
        pulumi.set(__self__, "vpc_connection_arn", vpc_connection_arn)

    @property
    @pulumi.getter(name="vpcConnectionArn")
    def vpc_connection_arn(self) -> pulumi.Input[str]:
        """
        <p>The Amazon Resource Name (ARN) for the VPC connection.</p>
        """
        return pulumi.get(self, "vpc_connection_arn")

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


@pulumi.input_type
class TemplateDataSetReferenceArgs:
    def __init__(__self__, *,
                 data_set_arn: pulumi.Input[str],
                 data_set_placeholder: pulumi.Input[str]):
        """
        <p>Dataset reference.</p>
        :param pulumi.Input[str] data_set_arn: <p>Dataset Amazon Resource Name (ARN).</p>
        :param pulumi.Input[str] data_set_placeholder: <p>Dataset placeholder.</p>
        """
        pulumi.set(__self__, "data_set_arn", data_set_arn)
        pulumi.set(__self__, "data_set_placeholder", data_set_placeholder)

    @property
    @pulumi.getter(name="dataSetArn")
    def data_set_arn(self) -> pulumi.Input[str]:
        """
        <p>Dataset Amazon Resource Name (ARN).</p>
        """
        return pulumi.get(self, "data_set_arn")

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

    @property
    @pulumi.getter(name="dataSetPlaceholder")
    def data_set_placeholder(self) -> pulumi.Input[str]:
        """
        <p>Dataset placeholder.</p>
        """
        return pulumi.get(self, "data_set_placeholder")

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


@pulumi.input_type
class TemplateResourcePermissionArgs:
    def __init__(__self__, *,
                 actions: pulumi.Input[Sequence[pulumi.Input[str]]],
                 principal: pulumi.Input[str]):
        """
        <p>Permission for the resource.</p>
        :param pulumi.Input[Sequence[pulumi.Input[str]]] actions: <p>The IAM action to grant or revoke permissions on.</p>
        :param pulumi.Input[str] principal: <p>The Amazon Resource Name (ARN) of the principal. This can be one of the
                           following:</p>
                       <ul>
                           <li>
                               <p>The ARN of an Amazon QuickSight user or group associated with a data source or dataset. (This is common.)</p>
                           </li>
                           <li>
                               <p>The ARN of an Amazon QuickSight user, group, or namespace associated with an analysis, dashboard, template, or theme. (This is common.)</p>
                           </li>
                           <li>
                               <p>The ARN of an AWS account root: This is an IAM ARN rather than a QuickSight
                                   ARN. Use this option only to share resources (templates) across AWS accounts.
                                   (This is less common.) </p>
                           </li>
                        </ul>
        """
        pulumi.set(__self__, "actions", actions)
        pulumi.set(__self__, "principal", principal)

    @property
    @pulumi.getter
    def actions(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        <p>The IAM action to grant or revoke permissions on.</p>
        """
        return pulumi.get(self, "actions")

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

    @property
    @pulumi.getter
    def principal(self) -> pulumi.Input[str]:
        """
        <p>The Amazon Resource Name (ARN) of the principal. This can be one of the
                    following:</p>
                <ul>
                    <li>
                        <p>The ARN of an Amazon QuickSight user or group associated with a data source or dataset. (This is common.)</p>
                    </li>
                    <li>
                        <p>The ARN of an Amazon QuickSight user, group, or namespace associated with an analysis, dashboard, template, or theme. (This is common.)</p>
                    </li>
                    <li>
                        <p>The ARN of an AWS account root: This is an IAM ARN rather than a QuickSight
                            ARN. Use this option only to share resources (templates) across AWS accounts.
                            (This is less common.) </p>
                    </li>
                 </ul>
        """
        return pulumi.get(self, "principal")

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


@pulumi.input_type
class TemplateTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        <p>The key or keys of the key-value pairs for the resource tag or tags assigned to the
                    resource.</p>
        :param pulumi.Input[str] key: <p>Tag key.</p>
        :param pulumi.Input[str] value: <p>Tag value.</p>
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        <p>Tag key.</p>
        """
        return pulumi.get(self, "key")

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

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        <p>Tag value.</p>
        """
        return pulumi.get(self, "value")

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


@pulumi.input_type
class TemplateTemplateSourceAnalysisArgs:
    def __init__(__self__, *,
                 arn: pulumi.Input[str],
                 data_set_references: pulumi.Input[Sequence[pulumi.Input['TemplateDataSetReferenceArgs']]]):
        """
        <p>The source analysis of the template.</p>
        :param pulumi.Input[str] arn: <p>The Amazon Resource Name (ARN) of the resource.</p>
        :param pulumi.Input[Sequence[pulumi.Input['TemplateDataSetReferenceArgs']]] data_set_references: <p>A structure containing information about the dataset references used as placeholders
                           in the template.</p>
        """
        pulumi.set(__self__, "arn", arn)
        pulumi.set(__self__, "data_set_references", data_set_references)

    @property
    @pulumi.getter
    def arn(self) -> pulumi.Input[str]:
        """
        <p>The Amazon Resource Name (ARN) of the resource.</p>
        """
        return pulumi.get(self, "arn")

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

    @property
    @pulumi.getter(name="dataSetReferences")
    def data_set_references(self) -> pulumi.Input[Sequence[pulumi.Input['TemplateDataSetReferenceArgs']]]:
        """
        <p>A structure containing information about the dataset references used as placeholders
                    in the template.</p>
        """
        return pulumi.get(self, "data_set_references")

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


@pulumi.input_type
class TemplateTemplateSourceEntityArgs:
    def __init__(__self__, *,
                 source_analysis: Optional[pulumi.Input['TemplateTemplateSourceAnalysisArgs']] = None,
                 source_template: Optional[pulumi.Input['TemplateTemplateSourceTemplateArgs']] = None):
        """
        <p>The source entity of the template.</p>
        """
        if source_analysis is not None:
            pulumi.set(__self__, "source_analysis", source_analysis)
        if source_template is not None:
            pulumi.set(__self__, "source_template", source_template)

    @property
    @pulumi.getter(name="sourceAnalysis")
    def source_analysis(self) -> Optional[pulumi.Input['TemplateTemplateSourceAnalysisArgs']]:
        return pulumi.get(self, "source_analysis")

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

    @property
    @pulumi.getter(name="sourceTemplate")
    def source_template(self) -> Optional[pulumi.Input['TemplateTemplateSourceTemplateArgs']]:
        return pulumi.get(self, "source_template")

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


@pulumi.input_type
class TemplateTemplateSourceTemplateArgs:
    def __init__(__self__, *,
                 arn: pulumi.Input[str]):
        """
        <p>The source template of the template.</p>
        :param pulumi.Input[str] arn: <p>The Amazon Resource Name (ARN) of the resource.</p>
        """
        pulumi.set(__self__, "arn", arn)

    @property
    @pulumi.getter
    def arn(self) -> pulumi.Input[str]:
        """
        <p>The Amazon Resource Name (ARN) of the resource.</p>
        """
        return pulumi.get(self, "arn")

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


@pulumi.input_type
class ThemeBorderStyleArgs:
    def __init__(__self__, *,
                 show: Optional[pulumi.Input[bool]] = None):
        """
        <p>The display options for tile borders for visuals.</p>
        :param pulumi.Input[bool] show: <p>The option to enable display of borders for visuals.</p>
        """
        if show is not None:
            pulumi.set(__self__, "show", show)

    @property
    @pulumi.getter
    def show(self) -> Optional[pulumi.Input[bool]]:
        """
        <p>The option to enable display of borders for visuals.</p>
        """
        return pulumi.get(self, "show")

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


@pulumi.input_type
class ThemeDataColorPaletteArgs:
    def __init__(__self__, *,
                 colors: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 empty_fill_color: Optional[pulumi.Input[str]] = None,
                 min_max_gradient: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        <p>The theme colors that are used for data colors in charts. The colors description is a
                    hexadecimal color code that consists of six alphanumerical characters, prefixed with
                        <code>#</code>, for example #37BFF5. </p>
        :param pulumi.Input[Sequence[pulumi.Input[str]]] colors: <p>The hexadecimal codes for the colors.</p>
        :param pulumi.Input[str] empty_fill_color: <p>The hexadecimal code of a color that applies to charts where a lack of data is
                           highlighted.</p>
        :param pulumi.Input[Sequence[pulumi.Input[str]]] min_max_gradient: <p>The minimum and maximum hexadecimal codes that describe a color gradient. </p>
        """
        if colors is not None:
            pulumi.set(__self__, "colors", colors)
        if empty_fill_color is not None:
            pulumi.set(__self__, "empty_fill_color", empty_fill_color)
        if min_max_gradient is not None:
            pulumi.set(__self__, "min_max_gradient", min_max_gradient)

    @property
    @pulumi.getter
    def colors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        <p>The hexadecimal codes for the colors.</p>
        """
        return pulumi.get(self, "colors")

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

    @property
    @pulumi.getter(name="emptyFillColor")
    def empty_fill_color(self) -> Optional[pulumi.Input[str]]:
        """
        <p>The hexadecimal code of a color that applies to charts where a lack of data is
                    highlighted.</p>
        """
        return pulumi.get(self, "empty_fill_color")

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

    @property
    @pulumi.getter(name="minMaxGradient")
    def min_max_gradient(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        <p>The minimum and maximum hexadecimal codes that describe a color gradient. </p>
        """
        return pulumi.get(self, "min_max_gradient")

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


@pulumi.input_type
class ThemeFontArgs:
    def __init__(__self__, *,
                 font_family: Optional[pulumi.Input[str]] = None):
        if font_family is not None:
            pulumi.set(__self__, "font_family", font_family)

    @property
    @pulumi.getter(name="fontFamily")
    def font_family(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "font_family")

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


@pulumi.input_type
class ThemeGutterStyleArgs:
    def __init__(__self__, *,
                 show: Optional[pulumi.Input[bool]] = None):
        """
        <p>The display options for gutter spacing between tiles on a sheet.</p>
        :param pulumi.Input[bool] show: <p>This Boolean value controls whether to display a gutter space between sheet tiles.
                       </p>
        """
        if show is not None:
            pulumi.set(__self__, "show", show)

    @property
    @pulumi.getter
    def show(self) -> Optional[pulumi.Input[bool]]:
        """
        <p>This Boolean value controls whether to display a gutter space between sheet tiles.
                </p>
        """
        return pulumi.get(self, "show")

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


@pulumi.input_type
class ThemeMarginStyleArgs:
    def __init__(__self__, *,
                 show: Optional[pulumi.Input[bool]] = None):
        """
        <p>The display options for margins around the outside edge of sheets.</p>
        :param pulumi.Input[bool] show: <p>This Boolean value controls whether to display sheet margins.</p>
        """
        if show is not None:
            pulumi.set(__self__, "show", show)

    @property
    @pulumi.getter
    def show(self) -> Optional[pulumi.Input[bool]]:
        """
        <p>This Boolean value controls whether to display sheet margins.</p>
        """
        return pulumi.get(self, "show")

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


@pulumi.input_type
class ThemeResourcePermissionArgs:
    def __init__(__self__, *,
                 actions: pulumi.Input[Sequence[pulumi.Input[str]]],
                 principal: pulumi.Input[str]):
        """
        <p>Permission for the resource.</p>
        :param pulumi.Input[Sequence[pulumi.Input[str]]] actions: <p>The IAM action to grant or revoke permissions on.</p>
        :param pulumi.Input[str] principal: <p>The Amazon Resource Name (ARN) of the principal. This can be one of the
                           following:</p>
                       <ul>
                           <li>
                               <p>The ARN of an Amazon QuickSight user or group associated with a data source or dataset. (This is common.)</p>
                           </li>
                           <li>
                               <p>The ARN of an Amazon QuickSight user, group, or namespace associated with an analysis, dashboard, template, or theme. (This is common.)</p>
                           </li>
                           <li>
                               <p>The ARN of an AWS account root: This is an IAM ARN rather than a QuickSight
                                   ARN. Use this option only to share resources (templates) across AWS accounts.
                                   (This is less common.) </p>
                           </li>
                        </ul>
        """
        pulumi.set(__self__, "actions", actions)
        pulumi.set(__self__, "principal", principal)

    @property
    @pulumi.getter
    def actions(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        <p>The IAM action to grant or revoke permissions on.</p>
        """
        return pulumi.get(self, "actions")

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

    @property
    @pulumi.getter
    def principal(self) -> pulumi.Input[str]:
        """
        <p>The Amazon Resource Name (ARN) of the principal. This can be one of the
                    following:</p>
                <ul>
                    <li>
                        <p>The ARN of an Amazon QuickSight user or group associated with a data source or dataset. (This is common.)</p>
                    </li>
                    <li>
                        <p>The ARN of an Amazon QuickSight user, group, or namespace associated with an analysis, dashboard, template, or theme. (This is common.)</p>
                    </li>
                    <li>
                        <p>The ARN of an AWS account root: This is an IAM ARN rather than a QuickSight
                            ARN. Use this option only to share resources (templates) across AWS accounts.
                            (This is less common.) </p>
                    </li>
                 </ul>
        """
        return pulumi.get(self, "principal")

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


@pulumi.input_type
class ThemeSheetStyleArgs:
    def __init__(__self__, *,
                 tile: Optional[pulumi.Input['ThemeTileStyleArgs']] = None,
                 tile_layout: Optional[pulumi.Input['ThemeTileLayoutStyleArgs']] = None):
        """
        <p>The theme display options for sheets. </p>
        """
        if tile is not None:
            pulumi.set(__self__, "tile", tile)
        if tile_layout is not None:
            pulumi.set(__self__, "tile_layout", tile_layout)

    @property
    @pulumi.getter
    def tile(self) -> Optional[pulumi.Input['ThemeTileStyleArgs']]:
        return pulumi.get(self, "tile")

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

    @property
    @pulumi.getter(name="tileLayout")
    def tile_layout(self) -> Optional[pulumi.Input['ThemeTileLayoutStyleArgs']]:
        return pulumi.get(self, "tile_layout")

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


@pulumi.input_type
class ThemeTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        <p>The key or keys of the key-value pairs for the resource tag or tags assigned to the
                    resource.</p>
        :param pulumi.Input[str] key: <p>Tag key.</p>
        :param pulumi.Input[str] value: <p>Tag value.</p>
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        <p>Tag key.</p>
        """
        return pulumi.get(self, "key")

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

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        <p>Tag value.</p>
        """
        return pulumi.get(self, "value")

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


@pulumi.input_type
class ThemeThemeConfigurationArgs:
    def __init__(__self__, *,
                 data_color_palette: Optional[pulumi.Input['ThemeDataColorPaletteArgs']] = None,
                 sheet: Optional[pulumi.Input['ThemeSheetStyleArgs']] = None,
                 typography: Optional[pulumi.Input['ThemeTypographyArgs']] = None,
                 u_i_color_palette: Optional[pulumi.Input['ThemeUIColorPaletteArgs']] = None):
        """
        <p>The theme configuration. This configuration contains all of the display properties for
                    a theme.</p>
        """
        if data_color_palette is not None:
            pulumi.set(__self__, "data_color_palette", data_color_palette)
        if sheet is not None:
            pulumi.set(__self__, "sheet", sheet)
        if typography is not None:
            pulumi.set(__self__, "typography", typography)
        if u_i_color_palette is not None:
            pulumi.set(__self__, "u_i_color_palette", u_i_color_palette)

    @property
    @pulumi.getter(name="dataColorPalette")
    def data_color_palette(self) -> Optional[pulumi.Input['ThemeDataColorPaletteArgs']]:
        return pulumi.get(self, "data_color_palette")

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

    @property
    @pulumi.getter
    def sheet(self) -> Optional[pulumi.Input['ThemeSheetStyleArgs']]:
        return pulumi.get(self, "sheet")

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

    @property
    @pulumi.getter
    def typography(self) -> Optional[pulumi.Input['ThemeTypographyArgs']]:
        return pulumi.get(self, "typography")

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

    @property
    @pulumi.getter(name="uIColorPalette")
    def u_i_color_palette(self) -> Optional[pulumi.Input['ThemeUIColorPaletteArgs']]:
        return pulumi.get(self, "u_i_color_palette")

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


@pulumi.input_type
class ThemeTileLayoutStyleArgs:
    def __init__(__self__, *,
                 gutter: Optional[pulumi.Input['ThemeGutterStyleArgs']] = None,
                 margin: Optional[pulumi.Input['ThemeMarginStyleArgs']] = None):
        """
        <p>The display options for the layout of tiles on a sheet.</p>
        """
        if gutter is not None:
            pulumi.set(__self__, "gutter", gutter)
        if margin is not None:
            pulumi.set(__self__, "margin", margin)

    @property
    @pulumi.getter
    def gutter(self) -> Optional[pulumi.Input['ThemeGutterStyleArgs']]:
        return pulumi.get(self, "gutter")

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

    @property
    @pulumi.getter
    def margin(self) -> Optional[pulumi.Input['ThemeMarginStyleArgs']]:
        return pulumi.get(self, "margin")

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


@pulumi.input_type
class ThemeTileStyleArgs:
    def __init__(__self__, *,
                 border: Optional[pulumi.Input['ThemeBorderStyleArgs']] = None):
        """
        <p>Display options related to tiles on a sheet.</p>
        """
        if border is not None:
            pulumi.set(__self__, "border", border)

    @property
    @pulumi.getter
    def border(self) -> Optional[pulumi.Input['ThemeBorderStyleArgs']]:
        return pulumi.get(self, "border")

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


@pulumi.input_type
class ThemeTypographyArgs:
    def __init__(__self__, *,
                 font_families: Optional[pulumi.Input[Sequence[pulumi.Input['ThemeFontArgs']]]] = None):
        if font_families is not None:
            pulumi.set(__self__, "font_families", font_families)

    @property
    @pulumi.getter(name="fontFamilies")
    def font_families(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ThemeFontArgs']]]]:
        return pulumi.get(self, "font_families")

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


@pulumi.input_type
class ThemeUIColorPaletteArgs:
    def __init__(__self__, *,
                 accent: Optional[pulumi.Input[str]] = None,
                 accent_foreground: Optional[pulumi.Input[str]] = None,
                 danger: Optional[pulumi.Input[str]] = None,
                 danger_foreground: Optional[pulumi.Input[str]] = None,
                 dimension: Optional[pulumi.Input[str]] = None,
                 dimension_foreground: Optional[pulumi.Input[str]] = None,
                 measure: Optional[pulumi.Input[str]] = None,
                 measure_foreground: Optional[pulumi.Input[str]] = None,
                 primary_background: Optional[pulumi.Input[str]] = None,
                 primary_foreground: Optional[pulumi.Input[str]] = None,
                 secondary_background: Optional[pulumi.Input[str]] = None,
                 secondary_foreground: Optional[pulumi.Input[str]] = None,
                 success: Optional[pulumi.Input[str]] = None,
                 success_foreground: Optional[pulumi.Input[str]] = None,
                 warning: Optional[pulumi.Input[str]] = None,
                 warning_foreground: Optional[pulumi.Input[str]] = None):
        """
        <p>The theme colors that apply to UI and to charts, excluding data colors. The colors
                    description is a hexadecimal color code that consists of six alphanumerical characters,
                    prefixed with <code>#</code>, for example #37BFF5. For more information, see <a href="https://docs.aws.amazon.com/quicksight/latest/user/themes-in-quicksight.html">Using Themes in Amazon QuickSight</a> in the <i>Amazon QuickSight User
                        Guide.</i>
                </p>
        :param pulumi.Input[str] accent: <p>This color is that applies to selected states and buttons.</p>
        :param pulumi.Input[str] accent_foreground: <p>The foreground color that applies to any text or other elements that appear over the
                           accent color.</p>
        :param pulumi.Input[str] danger: <p>The color that applies to error messages.</p>
        :param pulumi.Input[str] danger_foreground: <p>The foreground color that applies to any text or other elements that appear over the
                           error color.</p>
        :param pulumi.Input[str] dimension: <p>The color that applies to the names of fields that are identified as
                           dimensions.</p>
        :param pulumi.Input[str] dimension_foreground: <p>The foreground color that applies to any text or other elements that appear over the
                           dimension color.</p>
        :param pulumi.Input[str] measure: <p>The color that applies to the names of fields that are identified as measures.</p>
        :param pulumi.Input[str] measure_foreground: <p>The foreground color that applies to any text or other elements that appear over the
                           measure color.</p>
        :param pulumi.Input[str] primary_background: <p>The background color that applies to visuals and other high emphasis UI.</p>
        :param pulumi.Input[str] primary_foreground: <p>The color of text and other foreground elements that appear over the primary
                           background regions, such as grid lines, borders, table banding, icons, and so on.</p>
        :param pulumi.Input[str] secondary_background: <p>The background color that applies to the sheet background and sheet controls.</p>
        :param pulumi.Input[str] secondary_foreground: <p>The foreground color that applies to any sheet title, sheet control text, or UI that
                           appears over the secondary background.</p>
        :param pulumi.Input[str] success: <p>The color that applies to success messages, for example the check mark for a
                           successful download.</p>
        :param pulumi.Input[str] success_foreground: <p>The foreground color that applies to any text or other elements that appear over the
                           success color.</p>
        :param pulumi.Input[str] warning: <p>This color that applies to warning and informational messages.</p>
        :param pulumi.Input[str] warning_foreground: <p>The foreground color that applies to any text or other elements that appear over the
                           warning color.</p>
        """
        if accent is not None:
            pulumi.set(__self__, "accent", accent)
        if accent_foreground is not None:
            pulumi.set(__self__, "accent_foreground", accent_foreground)
        if danger is not None:
            pulumi.set(__self__, "danger", danger)
        if danger_foreground is not None:
            pulumi.set(__self__, "danger_foreground", danger_foreground)
        if dimension is not None:
            pulumi.set(__self__, "dimension", dimension)
        if dimension_foreground is not None:
            pulumi.set(__self__, "dimension_foreground", dimension_foreground)
        if measure is not None:
            pulumi.set(__self__, "measure", measure)
        if measure_foreground is not None:
            pulumi.set(__self__, "measure_foreground", measure_foreground)
        if primary_background is not None:
            pulumi.set(__self__, "primary_background", primary_background)
        if primary_foreground is not None:
            pulumi.set(__self__, "primary_foreground", primary_foreground)
        if secondary_background is not None:
            pulumi.set(__self__, "secondary_background", secondary_background)
        if secondary_foreground is not None:
            pulumi.set(__self__, "secondary_foreground", secondary_foreground)
        if success is not None:
            pulumi.set(__self__, "success", success)
        if success_foreground is not None:
            pulumi.set(__self__, "success_foreground", success_foreground)
        if warning is not None:
            pulumi.set(__self__, "warning", warning)
        if warning_foreground is not None:
            pulumi.set(__self__, "warning_foreground", warning_foreground)

    @property
    @pulumi.getter
    def accent(self) -> Optional[pulumi.Input[str]]:
        """
        <p>This color is that applies to selected states and buttons.</p>
        """
        return pulumi.get(self, "accent")

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

    @property
    @pulumi.getter(name="accentForeground")
    def accent_foreground(self) -> Optional[pulumi.Input[str]]:
        """
        <p>The foreground color that applies to any text or other elements that appear over the
                    accent color.</p>
        """
        return pulumi.get(self, "accent_foreground")

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

    @property
    @pulumi.getter
    def danger(self) -> Optional[pulumi.Input[str]]:
        """
        <p>The color that applies to error messages.</p>
        """
        return pulumi.get(self, "danger")

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

    @property
    @pulumi.getter(name="dangerForeground")
    def danger_foreground(self) -> Optional[pulumi.Input[str]]:
        """
        <p>The foreground color that applies to any text or other elements that appear over the
                    error color.</p>
        """
        return pulumi.get(self, "danger_foreground")

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

    @property
    @pulumi.getter
    def dimension(self) -> Optional[pulumi.Input[str]]:
        """
        <p>The color that applies to the names of fields that are identified as
                    dimensions.</p>
        """
        return pulumi.get(self, "dimension")

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

    @property
    @pulumi.getter(name="dimensionForeground")
    def dimension_foreground(self) -> Optional[pulumi.Input[str]]:
        """
        <p>The foreground color that applies to any text or other elements that appear over the
                    dimension color.</p>
        """
        return pulumi.get(self, "dimension_foreground")

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

    @property
    @pulumi.getter
    def measure(self) -> Optional[pulumi.Input[str]]:
        """
        <p>The color that applies to the names of fields that are identified as measures.</p>
        """
        return pulumi.get(self, "measure")

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

    @property
    @pulumi.getter(name="measureForeground")
    def measure_foreground(self) -> Optional[pulumi.Input[str]]:
        """
        <p>The foreground color that applies to any text or other elements that appear over the
                    measure color.</p>
        """
        return pulumi.get(self, "measure_foreground")

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

    @property
    @pulumi.getter(name="primaryBackground")
    def primary_background(self) -> Optional[pulumi.Input[str]]:
        """
        <p>The background color that applies to visuals and other high emphasis UI.</p>
        """
        return pulumi.get(self, "primary_background")

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

    @property
    @pulumi.getter(name="primaryForeground")
    def primary_foreground(self) -> Optional[pulumi.Input[str]]:
        """
        <p>The color of text and other foreground elements that appear over the primary
                    background regions, such as grid lines, borders, table banding, icons, and so on.</p>
        """
        return pulumi.get(self, "primary_foreground")

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

    @property
    @pulumi.getter(name="secondaryBackground")
    def secondary_background(self) -> Optional[pulumi.Input[str]]:
        """
        <p>The background color that applies to the sheet background and sheet controls.</p>
        """
        return pulumi.get(self, "secondary_background")

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

    @property
    @pulumi.getter(name="secondaryForeground")
    def secondary_foreground(self) -> Optional[pulumi.Input[str]]:
        """
        <p>The foreground color that applies to any sheet title, sheet control text, or UI that
                    appears over the secondary background.</p>
        """
        return pulumi.get(self, "secondary_foreground")

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

    @property
    @pulumi.getter
    def success(self) -> Optional[pulumi.Input[str]]:
        """
        <p>The color that applies to success messages, for example the check mark for a
                    successful download.</p>
        """
        return pulumi.get(self, "success")

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

    @property
    @pulumi.getter(name="successForeground")
    def success_foreground(self) -> Optional[pulumi.Input[str]]:
        """
        <p>The foreground color that applies to any text or other elements that appear over the
                    success color.</p>
        """
        return pulumi.get(self, "success_foreground")

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

    @property
    @pulumi.getter
    def warning(self) -> Optional[pulumi.Input[str]]:
        """
        <p>This color that applies to warning and informational messages.</p>
        """
        return pulumi.get(self, "warning")

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

    @property
    @pulumi.getter(name="warningForeground")
    def warning_foreground(self) -> Optional[pulumi.Input[str]]:
        """
        <p>The foreground color that applies to any text or other elements that appear over the
                    warning color.</p>
        """
        return pulumi.get(self, "warning_foreground")

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


