Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessDeniedException

type AccessDeniedException struct {
	Message *string

	RequestId *string
}

    You don't have access to this item. The provided credentials couldn't be validated. You might not be authorized to carry out the request. Make sure that your account is authorized to use the Amazon QuickSight service, that your policies have the correct permissions, and that you are using the correct access keys.

    func (*AccessDeniedException) Error

    func (e *AccessDeniedException) Error() string

    func (*AccessDeniedException) ErrorCode

    func (e *AccessDeniedException) ErrorCode() string

    func (*AccessDeniedException) ErrorFault

    func (e *AccessDeniedException) ErrorFault() smithy.ErrorFault

    func (*AccessDeniedException) ErrorMessage

    func (e *AccessDeniedException) ErrorMessage() string

    type AccountCustomization

    type AccountCustomization struct {
    
    	// The default theme for this QuickSight subscription.
    	DefaultTheme *string
    }

      The Amazon QuickSight customizations associated with your AWS account or a QuickSight namespace in a specific AWS Region.

      type AccountSettings

      type AccountSettings struct {
      
      	// The "account name" you provided for the QuickSight subscription in your AWS
      	// account. You create this name when you sign up for QuickSight. It is unique in
      	// all of AWS and it appears only in the console when users sign in.
      	AccountName *string
      
      	// The default QuickSight namespace for your AWS account.
      	DefaultNamespace *string
      
      	// The edition of QuickSight that you're currently subscribed to: Enterprise
      	// edition or Standard edition.
      	Edition Edition
      
      	// The main notification email for your QuickSight subscription.
      	NotificationEmail *string
      }

        The QuickSight settings associated with your AWS account.

        type ActiveIAMPolicyAssignment

        type ActiveIAMPolicyAssignment struct {
        
        	// A name for the IAM policy assignment.
        	AssignmentName *string
        
        	// The Amazon Resource Name (ARN) of the resource.
        	PolicyArn *string
        }

          The active AWS Identity and Access Management (IAM) policy assignment.

          type AdHocFilteringOption

          type AdHocFilteringOption struct {
          
          	// Availability status.
          	AvailabilityStatus DashboardBehavior
          }

            Ad hoc (one-time) filtering option.

            type AmazonElasticsearchParameters

            type AmazonElasticsearchParameters struct {
            
            	// The Amazon Elasticsearch Service domain.
            	//
            	// This member is required.
            	Domain *string
            }

              Amazon Elasticsearch Service parameters.

              type Analysis

              type Analysis struct {
              
              	// The ID of the analysis.
              	AnalysisId *string
              
              	// The Amazon Resource Name (ARN) of the analysis.
              	Arn *string
              
              	// The time that the analysis was created.
              	CreatedTime *time.Time
              
              	// The ARNs of the datasets of the analysis.
              	DataSetArns []string
              
              	// Errors associated with the analysis.
              	Errors []AnalysisError
              
              	// The time that the analysis was last updated.
              	LastUpdatedTime *time.Time
              
              	// The descriptive name of the analysis.
              	Name *string
              
              	// A list of the associated sheets with the unique identifier and name of each
              	// sheet.
              	Sheets []Sheet
              
              	// Status associated with the analysis.
              	Status ResourceStatus
              
              	// The ARN of the theme of the analysis.
              	ThemeArn *string
              }

                Metadata structure for an analysis in Amazon QuickSight

                type AnalysisError

                type AnalysisError struct {
                
                	// The message associated with the analysis error.
                	Message *string
                
                	// The type of the analysis error.
                	Type AnalysisErrorType
                }

                  A metadata error structure for an analysis.

                  type AnalysisErrorType

                  type AnalysisErrorType string
                  const (
                  	AnalysisErrorTypeAccessDenied                 AnalysisErrorType = "ACCESS_DENIED"
                  	AnalysisErrorTypeSourceNotFound               AnalysisErrorType = "SOURCE_NOT_FOUND"
                  	AnalysisErrorTypeDataSetNotFound              AnalysisErrorType = "DATA_SET_NOT_FOUND"
                  	AnalysisErrorTypeInternalFailure              AnalysisErrorType = "INTERNAL_FAILURE"
                  	AnalysisErrorTypeParameterValueIncompatible   AnalysisErrorType = "PARAMETER_VALUE_INCOMPATIBLE"
                  	AnalysisErrorTypeParameterTypeInvalid         AnalysisErrorType = "PARAMETER_TYPE_INVALID"
                  	AnalysisErrorTypeParameterNotFound            AnalysisErrorType = "PARAMETER_NOT_FOUND"
                  	AnalysisErrorTypeColumnTypeMismatch           AnalysisErrorType = "COLUMN_TYPE_MISMATCH"
                  	AnalysisErrorTypeColumnGeographicRoleMismatch AnalysisErrorType = "COLUMN_GEOGRAPHIC_ROLE_MISMATCH"
                  	AnalysisErrorTypeColumnReplacementMissing     AnalysisErrorType = "COLUMN_REPLACEMENT_MISSING"
                  )

                    Enum values for AnalysisErrorType

                    func (AnalysisErrorType) Values

                      Values returns all known values for AnalysisErrorType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                      type AnalysisFilterAttribute

                      type AnalysisFilterAttribute string
                      const (
                      	AnalysisFilterAttributeQuicksightUser AnalysisFilterAttribute = "QUICKSIGHT_USER"
                      )

                        Enum values for AnalysisFilterAttribute

                        func (AnalysisFilterAttribute) Values

                          Values returns all known values for AnalysisFilterAttribute. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                          type AnalysisSearchFilter

                          type AnalysisSearchFilter struct {
                          
                          	// The name of the value that you want to use as a filter, for example "Name":
                          	// "QUICKSIGHT_USER".
                          	Name AnalysisFilterAttribute
                          
                          	// The comparison operator that you want to use as a filter, for example
                          	// "Operator": "StringEquals".
                          	Operator FilterOperator
                          
                          	// The value of the named item, in this case QUICKSIGHT_USER, that you want to use
                          	// as a filter, for example "Value". An example is
                          	// "arn:aws:quicksight:us-east-1:1:user/default/UserName1".
                          	Value *string
                          }

                            A filter that you apply when searching for one or more analyses.

                            type AnalysisSourceEntity

                            type AnalysisSourceEntity struct {
                            
                            	// The source template for the source entity of the analysis.
                            	SourceTemplate *AnalysisSourceTemplate
                            }

                              The source entity of an analysis.

                              type AnalysisSourceTemplate

                              type AnalysisSourceTemplate struct {
                              
                              	// The Amazon Resource Name (ARN) of the source template of an analysis.
                              	//
                              	// This member is required.
                              	Arn *string
                              
                              	// The dataset references of the source template of an analysis.
                              	//
                              	// This member is required.
                              	DataSetReferences []DataSetReference
                              }

                                The source template of an analysis.

                                type AnalysisSummary

                                type AnalysisSummary struct {
                                
                                	// The ID of the analysis. This ID displays in the URL.
                                	AnalysisId *string
                                
                                	// The Amazon Resource Name (ARN) for the analysis.
                                	Arn *string
                                
                                	// The time that the analysis was created.
                                	CreatedTime *time.Time
                                
                                	// The time that the analysis was last updated.
                                	LastUpdatedTime *time.Time
                                
                                	// The name of the analysis. This name is displayed in the QuickSight console.
                                	Name *string
                                
                                	// The last known status for the analysis.
                                	Status ResourceStatus
                                }

                                  The summary metadata that describes an analysis.

                                  type AssignmentStatus

                                  type AssignmentStatus string
                                  const (
                                  	AssignmentStatusEnabled  AssignmentStatus = "ENABLED"
                                  	AssignmentStatusDraft    AssignmentStatus = "DRAFT"
                                  	AssignmentStatusDisabled AssignmentStatus = "DISABLED"
                                  )

                                    Enum values for AssignmentStatus

                                    func (AssignmentStatus) Values

                                      Values returns all known values for AssignmentStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                      type AthenaParameters

                                      type AthenaParameters struct {
                                      
                                      	// The workgroup that Amazon Athena uses.
                                      	WorkGroup *string
                                      }

                                        Amazon Athena parameters.

                                        type AuroraParameters

                                        type AuroraParameters struct {
                                        
                                        	// Database.
                                        	//
                                        	// This member is required.
                                        	Database *string
                                        
                                        	// Host.
                                        	//
                                        	// This member is required.
                                        	Host *string
                                        
                                        	// Port.
                                        	//
                                        	// This member is required.
                                        	Port int32
                                        }

                                          Amazon Aurora parameters.

                                          type AuroraPostgreSqlParameters

                                          type AuroraPostgreSqlParameters struct {
                                          
                                          	// Database.
                                          	//
                                          	// This member is required.
                                          	Database *string
                                          
                                          	// Host.
                                          	//
                                          	// This member is required.
                                          	Host *string
                                          
                                          	// Port.
                                          	//
                                          	// This member is required.
                                          	Port int32
                                          }

                                            Amazon Aurora with PostgreSQL compatibility parameters.

                                            type AwsIotAnalyticsParameters

                                            type AwsIotAnalyticsParameters struct {
                                            
                                            	// Dataset name.
                                            	//
                                            	// This member is required.
                                            	DataSetName *string
                                            }

                                              AWS IoT Analytics parameters.

                                              type BorderStyle

                                              type BorderStyle struct {
                                              
                                              	// The option to enable display of borders for visuals.
                                              	Show bool
                                              }

                                                The display options for tile borders for visuals.

                                                type CalculatedColumn

                                                type CalculatedColumn struct {
                                                
                                                	// A unique ID to identify a calculated column. During a dataset update, if the
                                                	// column ID of a calculated column matches that of an existing calculated column,
                                                	// Amazon QuickSight preserves the existing calculated column.
                                                	//
                                                	// This member is required.
                                                	ColumnId *string
                                                
                                                	// Column name.
                                                	//
                                                	// This member is required.
                                                	ColumnName *string
                                                
                                                	// An expression that defines the calculated column.
                                                	//
                                                	// This member is required.
                                                	Expression *string
                                                }

                                                  A calculated column for a dataset.

                                                  type CastColumnTypeOperation

                                                  type CastColumnTypeOperation struct {
                                                  
                                                  	// Column name.
                                                  	//
                                                  	// This member is required.
                                                  	ColumnName *string
                                                  
                                                  	// New column data type.
                                                  	//
                                                  	// This member is required.
                                                  	NewColumnType ColumnDataType
                                                  
                                                  	// When casting a column from string to datetime type, you can supply a string in a
                                                  	// format supported by Amazon QuickSight to denote the source data format.
                                                  	Format *string
                                                  }

                                                    A transform operation that casts a column to a different type.

                                                    type ColumnDataType

                                                    type ColumnDataType string
                                                    const (
                                                    	ColumnDataTypeString   ColumnDataType = "STRING"
                                                    	ColumnDataTypeInteger  ColumnDataType = "INTEGER"
                                                    	ColumnDataTypeDecimal  ColumnDataType = "DECIMAL"
                                                    	ColumnDataTypeDatetime ColumnDataType = "DATETIME"
                                                    )

                                                      Enum values for ColumnDataType

                                                      func (ColumnDataType) Values

                                                      func (ColumnDataType) Values() []ColumnDataType

                                                        Values returns all known values for ColumnDataType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                        type ColumnDescription

                                                        type ColumnDescription struct {
                                                        
                                                        	// The text of a description for a column.
                                                        	Text *string
                                                        }

                                                          Metadata that contains a description for a column.

                                                          type ColumnGroup

                                                          type ColumnGroup struct {
                                                          
                                                          	// Geospatial column group that denotes a hierarchy.
                                                          	GeoSpatialColumnGroup *GeoSpatialColumnGroup
                                                          }

                                                            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.

                                                            type ColumnGroupColumnSchema

                                                            type ColumnGroupColumnSchema struct {
                                                            
                                                            	// The name of the column group's column schema.
                                                            	Name *string
                                                            }

                                                              A structure describing the name, data type, and geographic role of the columns.

                                                              type ColumnGroupSchema

                                                              type ColumnGroupSchema struct {
                                                              
                                                              	// A structure containing the list of schemas for column group columns.
                                                              	ColumnGroupColumnSchemaList []ColumnGroupColumnSchema
                                                              
                                                              	// The name of the column group schema.
                                                              	Name *string
                                                              }

                                                                The column group schema.

                                                                type ColumnLevelPermissionRule

                                                                type ColumnLevelPermissionRule struct {
                                                                
                                                                	// An array of column names.
                                                                	ColumnNames []string
                                                                
                                                                	// An array of Amazon Resource Names (ARNs) for QuickSight users or groups.
                                                                	Principals []string
                                                                }

                                                                  A rule defined to grant access on one or more restricted columns. Each dataset can have multiple rules. To create a restricted column, you add it to one or more rules. Each rule must contain at least one column and at least one user or group. To be able to see a restricted column, a user or group needs to be added to a rule for that column.

                                                                  type ColumnSchema

                                                                  type ColumnSchema struct {
                                                                  
                                                                  	// The data type of the column schema.
                                                                  	DataType *string
                                                                  
                                                                  	// The geographic role of the column schema.
                                                                  	GeographicRole *string
                                                                  
                                                                  	// The name of the column schema.
                                                                  	Name *string
                                                                  }

                                                                    The column schema.

                                                                    type ColumnTag

                                                                    type ColumnTag struct {
                                                                    
                                                                    	// A description for a column.
                                                                    	ColumnDescription *ColumnDescription
                                                                    
                                                                    	// A geospatial role for a column.
                                                                    	ColumnGeographicRole GeoSpatialDataRole
                                                                    }

                                                                      A tag for a column in a TagColumnOperation structure. This is a variant type structure. For this structure to be valid, only one of the attributes can be non-null.

                                                                      type ConcurrentUpdatingException

                                                                      type ConcurrentUpdatingException struct {
                                                                      	Message *string
                                                                      
                                                                      	RequestId *string
                                                                      }

                                                                        A resource is already in a state that indicates an operation is happening that must complete before a new update can be applied.

                                                                        func (*ConcurrentUpdatingException) Error

                                                                        func (*ConcurrentUpdatingException) ErrorCode

                                                                        func (e *ConcurrentUpdatingException) ErrorCode() string

                                                                        func (*ConcurrentUpdatingException) ErrorFault

                                                                        func (*ConcurrentUpdatingException) ErrorMessage

                                                                        func (e *ConcurrentUpdatingException) ErrorMessage() string

                                                                        type ConflictException

                                                                        type ConflictException struct {
                                                                        	Message *string
                                                                        
                                                                        	RequestId *string
                                                                        }

                                                                          Updating or deleting a resource can cause an inconsistent state.

                                                                          func (*ConflictException) Error

                                                                          func (e *ConflictException) Error() string

                                                                          func (*ConflictException) ErrorCode

                                                                          func (e *ConflictException) ErrorCode() string

                                                                          func (*ConflictException) ErrorFault

                                                                          func (e *ConflictException) ErrorFault() smithy.ErrorFault

                                                                          func (*ConflictException) ErrorMessage

                                                                          func (e *ConflictException) ErrorMessage() string

                                                                          type CreateColumnsOperation

                                                                          type CreateColumnsOperation struct {
                                                                          
                                                                          	// Calculated columns to create.
                                                                          	//
                                                                          	// This member is required.
                                                                          	Columns []CalculatedColumn
                                                                          }

                                                                            A transform operation that creates calculated columns. Columns created in one such operation form a lexical closure.

                                                                            type CredentialPair

                                                                            type CredentialPair struct {
                                                                            
                                                                            	// Password.
                                                                            	//
                                                                            	// This member is required.
                                                                            	Password *string
                                                                            
                                                                            	// User name.
                                                                            	//
                                                                            	// This member is required.
                                                                            	Username *string
                                                                            
                                                                            	// 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 DataSourceParameters structure that's in the request
                                                                            	// with the structures in the AlternateDataSourceParameters 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 AlternateDataSourceParameters list is
                                                                            	// null, the DataSourceParameters originally used with these Credentials is
                                                                            	// automatically allowed.
                                                                            	AlternateDataSourceParameters []DataSourceParameters
                                                                            }

                                                                              The combination of user name and password that are used as credentials.

                                                                              type CustomSql

                                                                              type CustomSql struct {
                                                                              
                                                                              	// The Amazon Resource Name (ARN) of the data source.
                                                                              	//
                                                                              	// This member is required.
                                                                              	DataSourceArn *string
                                                                              
                                                                              	// A display name for the SQL query result.
                                                                              	//
                                                                              	// This member is required.
                                                                              	Name *string
                                                                              
                                                                              	// The SQL query.
                                                                              	//
                                                                              	// This member is required.
                                                                              	SqlQuery *string
                                                                              
                                                                              	// The column schema from the SQL query result set.
                                                                              	Columns []InputColumn
                                                                              }

                                                                                A physical table type built from the results of the custom SQL query.

                                                                                type Dashboard

                                                                                type Dashboard struct {
                                                                                
                                                                                	// The Amazon Resource Name (ARN) of the resource.
                                                                                	Arn *string
                                                                                
                                                                                	// The time that this dataset was created.
                                                                                	CreatedTime *time.Time
                                                                                
                                                                                	// Dashboard ID.
                                                                                	DashboardId *string
                                                                                
                                                                                	// The last time that this dataset was published.
                                                                                	LastPublishedTime *time.Time
                                                                                
                                                                                	// The last time that this dataset was updated.
                                                                                	LastUpdatedTime *time.Time
                                                                                
                                                                                	// A display name for the dashboard.
                                                                                	Name *string
                                                                                
                                                                                	// Version.
                                                                                	Version *DashboardVersion
                                                                                }

                                                                                  Dashboard.

                                                                                  type DashboardBehavior

                                                                                  type DashboardBehavior string
                                                                                  const (
                                                                                  	DashboardBehaviorEnabled  DashboardBehavior = "ENABLED"
                                                                                  	DashboardBehaviorDisabled DashboardBehavior = "DISABLED"
                                                                                  )

                                                                                    Enum values for DashboardBehavior

                                                                                    func (DashboardBehavior) Values

                                                                                      Values returns all known values for DashboardBehavior. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                      type DashboardError

                                                                                      type DashboardError struct {
                                                                                      
                                                                                      	// Message.
                                                                                      	Message *string
                                                                                      
                                                                                      	// Type.
                                                                                      	Type DashboardErrorType
                                                                                      }

                                                                                        Dashboard error.

                                                                                        type DashboardErrorType

                                                                                        type DashboardErrorType string
                                                                                        const (
                                                                                        	DashboardErrorTypeAccessDenied                 DashboardErrorType = "ACCESS_DENIED"
                                                                                        	DashboardErrorTypeSourceNotFound               DashboardErrorType = "SOURCE_NOT_FOUND"
                                                                                        	DashboardErrorTypeDataSetNotFound              DashboardErrorType = "DATA_SET_NOT_FOUND"
                                                                                        	DashboardErrorTypeInternalFailure              DashboardErrorType = "INTERNAL_FAILURE"
                                                                                        	DashboardErrorTypeParameterValueIncompatible   DashboardErrorType = "PARAMETER_VALUE_INCOMPATIBLE"
                                                                                        	DashboardErrorTypeParameterTypeInvalid         DashboardErrorType = "PARAMETER_TYPE_INVALID"
                                                                                        	DashboardErrorTypeParameterNotFound            DashboardErrorType = "PARAMETER_NOT_FOUND"
                                                                                        	DashboardErrorTypeColumnTypeMismatch           DashboardErrorType = "COLUMN_TYPE_MISMATCH"
                                                                                        	DashboardErrorTypeColumnGeographicRoleMismatch DashboardErrorType = "COLUMN_GEOGRAPHIC_ROLE_MISMATCH"
                                                                                        	DashboardErrorTypeColumnReplacementMissing     DashboardErrorType = "COLUMN_REPLACEMENT_MISSING"
                                                                                        )

                                                                                          Enum values for DashboardErrorType

                                                                                          func (DashboardErrorType) Values

                                                                                            Values returns all known values for DashboardErrorType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                            type DashboardFilterAttribute

                                                                                            type DashboardFilterAttribute string
                                                                                            const (
                                                                                            	DashboardFilterAttributeQuicksightUser DashboardFilterAttribute = "QUICKSIGHT_USER"
                                                                                            )

                                                                                              Enum values for DashboardFilterAttribute

                                                                                              func (DashboardFilterAttribute) Values

                                                                                                Values returns all known values for DashboardFilterAttribute. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                type DashboardPublishOptions

                                                                                                type DashboardPublishOptions struct {
                                                                                                
                                                                                                	// Ad hoc (one-time) filtering option.
                                                                                                	AdHocFilteringOption *AdHocFilteringOption
                                                                                                
                                                                                                	// Export to .csv option.
                                                                                                	ExportToCSVOption *ExportToCSVOption
                                                                                                
                                                                                                	// Sheet controls option.
                                                                                                	SheetControlsOption *SheetControlsOption
                                                                                                }

                                                                                                  Dashboard publish options.

                                                                                                  type DashboardSearchFilter

                                                                                                  type DashboardSearchFilter struct {
                                                                                                  
                                                                                                  	// The comparison operator that you want to use as a filter, for example,
                                                                                                  	// "Operator": "StringEquals".
                                                                                                  	//
                                                                                                  	// This member is required.
                                                                                                  	Operator FilterOperator
                                                                                                  
                                                                                                  	// The name of the value that you want to use as a filter, for example, "Name":
                                                                                                  	// "QUICKSIGHT_USER".
                                                                                                  	Name DashboardFilterAttribute
                                                                                                  
                                                                                                  	// The value of the named item, in this case QUICKSIGHT_USER, that you want to use
                                                                                                  	// as a filter, for example, "Value":
                                                                                                  	// "arn:aws:quicksight:us-east-1:1:user/default/UserName1".
                                                                                                  	Value *string
                                                                                                  }

                                                                                                    A filter that you apply when searching for dashboards.

                                                                                                    type DashboardSourceEntity

                                                                                                    type DashboardSourceEntity struct {
                                                                                                    
                                                                                                    	// Source template.
                                                                                                    	SourceTemplate *DashboardSourceTemplate
                                                                                                    }

                                                                                                      Dashboard source entity.

                                                                                                      type DashboardSourceTemplate

                                                                                                      type DashboardSourceTemplate struct {
                                                                                                      
                                                                                                      	// The Amazon Resource Name (ARN) of the resource.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	Arn *string
                                                                                                      
                                                                                                      	// Dataset references.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	DataSetReferences []DataSetReference
                                                                                                      }

                                                                                                        Dashboard source template.

                                                                                                        type DashboardSummary

                                                                                                        type DashboardSummary struct {
                                                                                                        
                                                                                                        	// The Amazon Resource Name (ARN) of the resource.
                                                                                                        	Arn *string
                                                                                                        
                                                                                                        	// The time that this dashboard was created.
                                                                                                        	CreatedTime *time.Time
                                                                                                        
                                                                                                        	// Dashboard ID.
                                                                                                        	DashboardId *string
                                                                                                        
                                                                                                        	// The last time that this dashboard was published.
                                                                                                        	LastPublishedTime *time.Time
                                                                                                        
                                                                                                        	// The last time that this dashboard was updated.
                                                                                                        	LastUpdatedTime *time.Time
                                                                                                        
                                                                                                        	// A display name for the dashboard.
                                                                                                        	Name *string
                                                                                                        
                                                                                                        	// Published version number.
                                                                                                        	PublishedVersionNumber *int64
                                                                                                        }

                                                                                                          Dashboard summary.

                                                                                                          type DashboardUIState

                                                                                                          type DashboardUIState string
                                                                                                          const (
                                                                                                          	DashboardUIStateExpanded  DashboardUIState = "EXPANDED"
                                                                                                          	DashboardUIStateCollapsed DashboardUIState = "COLLAPSED"
                                                                                                          )

                                                                                                            Enum values for DashboardUIState

                                                                                                            func (DashboardUIState) Values

                                                                                                              Values returns all known values for DashboardUIState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                              type DashboardVersion

                                                                                                              type DashboardVersion struct {
                                                                                                              
                                                                                                              	// The Amazon Resource Name (ARN) of the resource.
                                                                                                              	Arn *string
                                                                                                              
                                                                                                              	// The time that this dashboard version was created.
                                                                                                              	CreatedTime *time.Time
                                                                                                              
                                                                                                              	// The Amazon Resource Numbers (ARNs) for the datasets that are associated with
                                                                                                              	// this version of the dashboard.
                                                                                                              	DataSetArns []string
                                                                                                              
                                                                                                              	// Description.
                                                                                                              	Description *string
                                                                                                              
                                                                                                              	// Errors associated with this dashboard version.
                                                                                                              	Errors []DashboardError
                                                                                                              
                                                                                                              	// A list of the associated sheets with the unique identifier and name of each
                                                                                                              	// sheet.
                                                                                                              	Sheets []Sheet
                                                                                                              
                                                                                                              	// Source entity ARN.
                                                                                                              	SourceEntityArn *string
                                                                                                              
                                                                                                              	// The HTTP status of the request.
                                                                                                              	Status ResourceStatus
                                                                                                              
                                                                                                              	// The ARN of the theme associated with a version of the dashboard.
                                                                                                              	ThemeArn *string
                                                                                                              
                                                                                                              	// Version number for this version of the dashboard.
                                                                                                              	VersionNumber *int64
                                                                                                              }

                                                                                                                Dashboard version.

                                                                                                                type DashboardVersionSummary

                                                                                                                type DashboardVersionSummary struct {
                                                                                                                
                                                                                                                	// The Amazon Resource Name (ARN) of the resource.
                                                                                                                	Arn *string
                                                                                                                
                                                                                                                	// The time that this dashboard version was created.
                                                                                                                	CreatedTime *time.Time
                                                                                                                
                                                                                                                	// Description.
                                                                                                                	Description *string
                                                                                                                
                                                                                                                	// Source entity ARN.
                                                                                                                	SourceEntityArn *string
                                                                                                                
                                                                                                                	// The HTTP status of the request.
                                                                                                                	Status ResourceStatus
                                                                                                                
                                                                                                                	// Version number.
                                                                                                                	VersionNumber *int64
                                                                                                                }

                                                                                                                  Dashboard version summary.

                                                                                                                  type DataColorPalette

                                                                                                                  type DataColorPalette struct {
                                                                                                                  
                                                                                                                  	// The hexadecimal codes for the colors.
                                                                                                                  	Colors []string
                                                                                                                  
                                                                                                                  	// The hexadecimal code of a color that applies to charts where a lack of data is
                                                                                                                  	// highlighted.
                                                                                                                  	EmptyFillColor *string
                                                                                                                  
                                                                                                                  	// The minimum and maximum hexadecimal codes that describe a color gradient.
                                                                                                                  	MinMaxGradient []string
                                                                                                                  }

                                                                                                                    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 #, for example #37BFF5.

                                                                                                                    type DataSet

                                                                                                                    type DataSet struct {
                                                                                                                    
                                                                                                                    	// The Amazon Resource Name (ARN) of the resource.
                                                                                                                    	Arn *string
                                                                                                                    
                                                                                                                    	// Groupings of columns that work together in certain Amazon QuickSight features.
                                                                                                                    	// Currently, only geospatial hierarchy is supported.
                                                                                                                    	ColumnGroups []ColumnGroup
                                                                                                                    
                                                                                                                    	// A set of one or more definitions of a ColumnLevelPermissionRule.
                                                                                                                    	ColumnLevelPermissionRules []ColumnLevelPermissionRule
                                                                                                                    
                                                                                                                    	// The amount of SPICE capacity used by this dataset. This is 0 if the dataset
                                                                                                                    	// isn't imported into SPICE.
                                                                                                                    	ConsumedSpiceCapacityInBytes int64
                                                                                                                    
                                                                                                                    	// The time that this dataset was created.
                                                                                                                    	CreatedTime *time.Time
                                                                                                                    
                                                                                                                    	// The ID of the dataset.
                                                                                                                    	DataSetId *string
                                                                                                                    
                                                                                                                    	// The folder that contains fields and nested subfolders for your dataset.
                                                                                                                    	FieldFolders map[string]FieldFolder
                                                                                                                    
                                                                                                                    	// A value that indicates whether you want to import the data into SPICE.
                                                                                                                    	ImportMode DataSetImportMode
                                                                                                                    
                                                                                                                    	// The last time that this dataset was updated.
                                                                                                                    	LastUpdatedTime *time.Time
                                                                                                                    
                                                                                                                    	// Configures the combination and transformation of the data from the physical
                                                                                                                    	// tables.
                                                                                                                    	LogicalTableMap map[string]LogicalTable
                                                                                                                    
                                                                                                                    	// A display name for the dataset.
                                                                                                                    	Name *string
                                                                                                                    
                                                                                                                    	// The list of columns after all transforms. These columns are available in
                                                                                                                    	// templates, analyses, and dashboards.
                                                                                                                    	OutputColumns []OutputColumn
                                                                                                                    
                                                                                                                    	// Declares the physical tables that are available in the underlying data sources.
                                                                                                                    	PhysicalTableMap map[string]PhysicalTable
                                                                                                                    
                                                                                                                    	// The row-level security configuration for the dataset.
                                                                                                                    	RowLevelPermissionDataSet *RowLevelPermissionDataSet
                                                                                                                    }

                                                                                                                      Dataset.

                                                                                                                      type DataSetConfiguration

                                                                                                                      type DataSetConfiguration struct {
                                                                                                                      
                                                                                                                      	// A structure containing the list of column group schemas.
                                                                                                                      	ColumnGroupSchemaList []ColumnGroupSchema
                                                                                                                      
                                                                                                                      	// Dataset schema.
                                                                                                                      	DataSetSchema *DataSetSchema
                                                                                                                      
                                                                                                                      	// Placeholder.
                                                                                                                      	Placeholder *string
                                                                                                                      }

                                                                                                                        Dataset configuration.

                                                                                                                        type DataSetImportMode

                                                                                                                        type DataSetImportMode string
                                                                                                                        const (
                                                                                                                        	DataSetImportModeSpice       DataSetImportMode = "SPICE"
                                                                                                                        	DataSetImportModeDirectQuery DataSetImportMode = "DIRECT_QUERY"
                                                                                                                        )

                                                                                                                          Enum values for DataSetImportMode

                                                                                                                          func (DataSetImportMode) Values

                                                                                                                            Values returns all known values for DataSetImportMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                            type DataSetReference

                                                                                                                            type DataSetReference struct {
                                                                                                                            
                                                                                                                            	// Dataset Amazon Resource Name (ARN).
                                                                                                                            	//
                                                                                                                            	// This member is required.
                                                                                                                            	DataSetArn *string
                                                                                                                            
                                                                                                                            	// Dataset placeholder.
                                                                                                                            	//
                                                                                                                            	// This member is required.
                                                                                                                            	DataSetPlaceholder *string
                                                                                                                            }

                                                                                                                              Dataset reference.

                                                                                                                              type DataSetSchema

                                                                                                                              type DataSetSchema struct {
                                                                                                                              
                                                                                                                              	// A structure containing the list of column schemas.
                                                                                                                              	ColumnSchemaList []ColumnSchema
                                                                                                                              }

                                                                                                                                Dataset schema.

                                                                                                                                type DataSetSummary

                                                                                                                                type DataSetSummary struct {
                                                                                                                                
                                                                                                                                	// The Amazon Resource Name (ARN) of the dataset.
                                                                                                                                	Arn *string
                                                                                                                                
                                                                                                                                	// A value that indicates if the dataset has column level permission configured.
                                                                                                                                	ColumnLevelPermissionRulesApplied bool
                                                                                                                                
                                                                                                                                	// The time that this dataset was created.
                                                                                                                                	CreatedTime *time.Time
                                                                                                                                
                                                                                                                                	// The ID of the dataset.
                                                                                                                                	DataSetId *string
                                                                                                                                
                                                                                                                                	// A value that indicates whether you want to import the data into SPICE.
                                                                                                                                	ImportMode DataSetImportMode
                                                                                                                                
                                                                                                                                	// The last time that this dataset was updated.
                                                                                                                                	LastUpdatedTime *time.Time
                                                                                                                                
                                                                                                                                	// A display name for the dataset.
                                                                                                                                	Name *string
                                                                                                                                
                                                                                                                                	// The row-level security configuration for the dataset.
                                                                                                                                	RowLevelPermissionDataSet *RowLevelPermissionDataSet
                                                                                                                                }

                                                                                                                                  Dataset summary.

                                                                                                                                  type DataSource

                                                                                                                                  type DataSource struct {
                                                                                                                                  
                                                                                                                                  	// A set of alternate data source parameters that you want to share for the
                                                                                                                                  	// credentials stored with this data source. 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 DataSourceParameters structure
                                                                                                                                  	// that's in the request with the structures in the AlternateDataSourceParameters
                                                                                                                                  	// allow list. If the structures are an exact match, the request is allowed to use
                                                                                                                                  	// the credentials from this existing data source. If the
                                                                                                                                  	// AlternateDataSourceParameters list is null, the Credentials originally used with
                                                                                                                                  	// this DataSourceParameters are automatically allowed.
                                                                                                                                  	AlternateDataSourceParameters []DataSourceParameters
                                                                                                                                  
                                                                                                                                  	// The Amazon Resource Name (ARN) of the data source.
                                                                                                                                  	Arn *string
                                                                                                                                  
                                                                                                                                  	// The time that this data source was created.
                                                                                                                                  	CreatedTime *time.Time
                                                                                                                                  
                                                                                                                                  	// The ID of the data source. This ID is unique per AWS Region for each AWS
                                                                                                                                  	// account.
                                                                                                                                  	DataSourceId *string
                                                                                                                                  
                                                                                                                                  	// The parameters that Amazon QuickSight uses to connect to your underlying source.
                                                                                                                                  	// This is a variant type structure. For this structure to be valid, only one of
                                                                                                                                  	// the attributes can be non-null.
                                                                                                                                  	DataSourceParameters DataSourceParameters
                                                                                                                                  
                                                                                                                                  	// Error information from the last update or the creation of the data source.
                                                                                                                                  	ErrorInfo *DataSourceErrorInfo
                                                                                                                                  
                                                                                                                                  	// The last time that this data source was updated.
                                                                                                                                  	LastUpdatedTime *time.Time
                                                                                                                                  
                                                                                                                                  	// A display name for the data source.
                                                                                                                                  	Name *string
                                                                                                                                  
                                                                                                                                  	// Secure Socket Layer (SSL) properties that apply when QuickSight connects to your
                                                                                                                                  	// underlying source.
                                                                                                                                  	SslProperties *SslProperties
                                                                                                                                  
                                                                                                                                  	// The HTTP status of the request.
                                                                                                                                  	Status ResourceStatus
                                                                                                                                  
                                                                                                                                  	// The type of the data source. This type indicates which database engine the data
                                                                                                                                  	// source connects to.
                                                                                                                                  	Type DataSourceType
                                                                                                                                  
                                                                                                                                  	// The VPC connection information. You need to use this parameter only when you
                                                                                                                                  	// want QuickSight to use a VPC connection when connecting to your underlying
                                                                                                                                  	// source.
                                                                                                                                  	VpcConnectionProperties *VpcConnectionProperties
                                                                                                                                  }

                                                                                                                                    The structure of a data source.

                                                                                                                                    type DataSourceCredentials

                                                                                                                                    type DataSourceCredentials struct {
                                                                                                                                    
                                                                                                                                    	// The Amazon Resource Name (ARN) of a data source that has the credential pair
                                                                                                                                    	// that you want to use. When CopySourceArn is not null, the credential pair from
                                                                                                                                    	// the data source in the ARN is used as the credentials for the
                                                                                                                                    	// DataSourceCredentials structure.
                                                                                                                                    	CopySourceArn *string
                                                                                                                                    
                                                                                                                                    	// Credential pair. For more information, see CredentialPair.
                                                                                                                                    	CredentialPair *CredentialPair
                                                                                                                                    }

                                                                                                                                      Data source credentials. This is a variant type structure. For this structure to be valid, only one of the attributes can be non-null.

                                                                                                                                      type DataSourceErrorInfo

                                                                                                                                      type DataSourceErrorInfo struct {
                                                                                                                                      
                                                                                                                                      	// Error message.
                                                                                                                                      	Message *string
                                                                                                                                      
                                                                                                                                      	// Error type.
                                                                                                                                      	Type DataSourceErrorInfoType
                                                                                                                                      }

                                                                                                                                        Error information for the data source creation or update.

                                                                                                                                        type DataSourceErrorInfoType

                                                                                                                                        type DataSourceErrorInfoType string
                                                                                                                                        const (
                                                                                                                                        	DataSourceErrorInfoTypeAccessDenied              DataSourceErrorInfoType = "ACCESS_DENIED"
                                                                                                                                        	DataSourceErrorInfoTypeCopySourceNotFound        DataSourceErrorInfoType = "COPY_SOURCE_NOT_FOUND"
                                                                                                                                        	DataSourceErrorInfoTypeTimeout                   DataSourceErrorInfoType = "TIMEOUT"
                                                                                                                                        	DataSourceErrorInfoTypeEngineVersionNotSupported DataSourceErrorInfoType = "ENGINE_VERSION_NOT_SUPPORTED"
                                                                                                                                        	DataSourceErrorInfoTypeUnknownHost               DataSourceErrorInfoType = "UNKNOWN_HOST"
                                                                                                                                        	DataSourceErrorInfoTypeGenericSqlFailure         DataSourceErrorInfoType = "GENERIC_SQL_FAILURE"
                                                                                                                                        	DataSourceErrorInfoTypeConflict                  DataSourceErrorInfoType = "CONFLICT"
                                                                                                                                        	DataSourceErrorInfoTypeUnknown                   DataSourceErrorInfoType = "UNKNOWN"
                                                                                                                                        )

                                                                                                                                          Enum values for DataSourceErrorInfoType

                                                                                                                                          func (DataSourceErrorInfoType) Values

                                                                                                                                            Values returns all known values for DataSourceErrorInfoType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                            type DataSourceParameters

                                                                                                                                            type DataSourceParameters interface {
                                                                                                                                            	// contains filtered or unexported methods
                                                                                                                                            }

                                                                                                                                              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.

                                                                                                                                              The following types satisfy this interface:

                                                                                                                                              DataSourceParametersMemberAmazonElasticsearchParameters
                                                                                                                                              DataSourceParametersMemberAthenaParameters
                                                                                                                                              DataSourceParametersMemberAuroraParameters
                                                                                                                                              DataSourceParametersMemberAuroraPostgreSqlParameters
                                                                                                                                              DataSourceParametersMemberAwsIotAnalyticsParameters
                                                                                                                                              DataSourceParametersMemberJiraParameters
                                                                                                                                              DataSourceParametersMemberMariaDbParameters
                                                                                                                                              DataSourceParametersMemberMySqlParameters
                                                                                                                                              DataSourceParametersMemberOracleParameters
                                                                                                                                              DataSourceParametersMemberPostgreSqlParameters
                                                                                                                                              DataSourceParametersMemberPrestoParameters
                                                                                                                                              DataSourceParametersMemberRdsParameters
                                                                                                                                              DataSourceParametersMemberRedshiftParameters
                                                                                                                                              DataSourceParametersMemberS3Parameters
                                                                                                                                              DataSourceParametersMemberServiceNowParameters
                                                                                                                                              DataSourceParametersMemberSnowflakeParameters
                                                                                                                                              DataSourceParametersMemberSparkParameters
                                                                                                                                              DataSourceParametersMemberSqlServerParameters
                                                                                                                                              DataSourceParametersMemberTeradataParameters
                                                                                                                                              DataSourceParametersMemberTwitterParameters
                                                                                                                                              
                                                                                                                                              Example (OutputUsage)
                                                                                                                                              Output:
                                                                                                                                              
                                                                                                                                              

                                                                                                                                              type DataSourceParametersMemberAmazonElasticsearchParameters

                                                                                                                                              type DataSourceParametersMemberAmazonElasticsearchParameters struct {
                                                                                                                                              	Value AmazonElasticsearchParameters
                                                                                                                                              }

                                                                                                                                                Amazon Elasticsearch Service parameters.

                                                                                                                                                type DataSourceParametersMemberAthenaParameters

                                                                                                                                                type DataSourceParametersMemberAthenaParameters struct {
                                                                                                                                                	Value AthenaParameters
                                                                                                                                                }

                                                                                                                                                  Amazon Athena parameters.

                                                                                                                                                  type DataSourceParametersMemberAuroraParameters

                                                                                                                                                  type DataSourceParametersMemberAuroraParameters struct {
                                                                                                                                                  	Value AuroraParameters
                                                                                                                                                  }

                                                                                                                                                    Amazon Aurora MySQL parameters.

                                                                                                                                                    type DataSourceParametersMemberAuroraPostgreSqlParameters

                                                                                                                                                    type DataSourceParametersMemberAuroraPostgreSqlParameters struct {
                                                                                                                                                    	Value AuroraPostgreSqlParameters
                                                                                                                                                    }

                                                                                                                                                      Aurora PostgreSQL parameters.

                                                                                                                                                      type DataSourceParametersMemberAwsIotAnalyticsParameters

                                                                                                                                                      type DataSourceParametersMemberAwsIotAnalyticsParameters struct {
                                                                                                                                                      	Value AwsIotAnalyticsParameters
                                                                                                                                                      }

                                                                                                                                                        AWS IoT Analytics parameters.

                                                                                                                                                        type DataSourceParametersMemberJiraParameters

                                                                                                                                                        type DataSourceParametersMemberJiraParameters struct {
                                                                                                                                                        	Value JiraParameters
                                                                                                                                                        }

                                                                                                                                                          Jira parameters.

                                                                                                                                                          type DataSourceParametersMemberMariaDbParameters

                                                                                                                                                          type DataSourceParametersMemberMariaDbParameters struct {
                                                                                                                                                          	Value MariaDbParameters
                                                                                                                                                          }

                                                                                                                                                            MariaDB parameters.

                                                                                                                                                            type DataSourceParametersMemberMySqlParameters

                                                                                                                                                            type DataSourceParametersMemberMySqlParameters struct {
                                                                                                                                                            	Value MySqlParameters
                                                                                                                                                            }

                                                                                                                                                              MySQL parameters.

                                                                                                                                                              type DataSourceParametersMemberOracleParameters

                                                                                                                                                              type DataSourceParametersMemberOracleParameters struct {
                                                                                                                                                              	Value OracleParameters
                                                                                                                                                              }

                                                                                                                                                                Oracle parameters.

                                                                                                                                                                type DataSourceParametersMemberPostgreSqlParameters

                                                                                                                                                                type DataSourceParametersMemberPostgreSqlParameters struct {
                                                                                                                                                                	Value PostgreSqlParameters
                                                                                                                                                                }

                                                                                                                                                                  PostgreSQL parameters.

                                                                                                                                                                  type DataSourceParametersMemberPrestoParameters

                                                                                                                                                                  type DataSourceParametersMemberPrestoParameters struct {
                                                                                                                                                                  	Value PrestoParameters
                                                                                                                                                                  }

                                                                                                                                                                    Presto parameters.

                                                                                                                                                                    type DataSourceParametersMemberRdsParameters

                                                                                                                                                                    type DataSourceParametersMemberRdsParameters struct {
                                                                                                                                                                    	Value RdsParameters
                                                                                                                                                                    }

                                                                                                                                                                      Amazon RDS parameters.

                                                                                                                                                                      type DataSourceParametersMemberRedshiftParameters

                                                                                                                                                                      type DataSourceParametersMemberRedshiftParameters struct {
                                                                                                                                                                      	Value RedshiftParameters
                                                                                                                                                                      }

                                                                                                                                                                        Amazon Redshift parameters.

                                                                                                                                                                        type DataSourceParametersMemberS3Parameters

                                                                                                                                                                        type DataSourceParametersMemberS3Parameters struct {
                                                                                                                                                                        	Value S3Parameters
                                                                                                                                                                        }

                                                                                                                                                                          S3 parameters.

                                                                                                                                                                          type DataSourceParametersMemberServiceNowParameters

                                                                                                                                                                          type DataSourceParametersMemberServiceNowParameters struct {
                                                                                                                                                                          	Value ServiceNowParameters
                                                                                                                                                                          }

                                                                                                                                                                            ServiceNow parameters.

                                                                                                                                                                            type DataSourceParametersMemberSnowflakeParameters

                                                                                                                                                                            type DataSourceParametersMemberSnowflakeParameters struct {
                                                                                                                                                                            	Value SnowflakeParameters
                                                                                                                                                                            }

                                                                                                                                                                              Snowflake parameters.

                                                                                                                                                                              type DataSourceParametersMemberSparkParameters

                                                                                                                                                                              type DataSourceParametersMemberSparkParameters struct {
                                                                                                                                                                              	Value SparkParameters
                                                                                                                                                                              }

                                                                                                                                                                                Spark parameters.

                                                                                                                                                                                type DataSourceParametersMemberSqlServerParameters

                                                                                                                                                                                type DataSourceParametersMemberSqlServerParameters struct {
                                                                                                                                                                                	Value SqlServerParameters
                                                                                                                                                                                }

                                                                                                                                                                                  SQL Server parameters.

                                                                                                                                                                                  type DataSourceParametersMemberTeradataParameters

                                                                                                                                                                                  type DataSourceParametersMemberTeradataParameters struct {
                                                                                                                                                                                  	Value TeradataParameters
                                                                                                                                                                                  }

                                                                                                                                                                                    Teradata parameters.

                                                                                                                                                                                    type DataSourceParametersMemberTwitterParameters

                                                                                                                                                                                    type DataSourceParametersMemberTwitterParameters struct {
                                                                                                                                                                                    	Value TwitterParameters
                                                                                                                                                                                    }

                                                                                                                                                                                      Twitter parameters.

                                                                                                                                                                                      type DataSourceType

                                                                                                                                                                                      type DataSourceType string
                                                                                                                                                                                      const (
                                                                                                                                                                                      	DataSourceTypeAdobeAnalytics      DataSourceType = "ADOBE_ANALYTICS"
                                                                                                                                                                                      	DataSourceTypeAmazonElasticsearch DataSourceType = "AMAZON_ELASTICSEARCH"
                                                                                                                                                                                      	DataSourceTypeAthena              DataSourceType = "ATHENA"
                                                                                                                                                                                      	DataSourceTypeAurora              DataSourceType = "AURORA"
                                                                                                                                                                                      	DataSourceTypeAuroraPostgresql    DataSourceType = "AURORA_POSTGRESQL"
                                                                                                                                                                                      	DataSourceTypeAwsIotAnalytics     DataSourceType = "AWS_IOT_ANALYTICS"
                                                                                                                                                                                      	DataSourceTypeGithub              DataSourceType = "GITHUB"
                                                                                                                                                                                      	DataSourceTypeJira                DataSourceType = "JIRA"
                                                                                                                                                                                      	DataSourceTypeMariadb             DataSourceType = "MARIADB"
                                                                                                                                                                                      	DataSourceTypeMysql               DataSourceType = "MYSQL"
                                                                                                                                                                                      	DataSourceTypeOracle              DataSourceType = "ORACLE"
                                                                                                                                                                                      	DataSourceTypePostgresql          DataSourceType = "POSTGRESQL"
                                                                                                                                                                                      	DataSourceTypePresto              DataSourceType = "PRESTO"
                                                                                                                                                                                      	DataSourceTypeRedshift            DataSourceType = "REDSHIFT"
                                                                                                                                                                                      	DataSourceTypeS3                  DataSourceType = "S3"
                                                                                                                                                                                      	DataSourceTypeSalesforce          DataSourceType = "SALESFORCE"
                                                                                                                                                                                      	DataSourceTypeServicenow          DataSourceType = "SERVICENOW"
                                                                                                                                                                                      	DataSourceTypeSnowflake           DataSourceType = "SNOWFLAKE"
                                                                                                                                                                                      	DataSourceTypeSpark               DataSourceType = "SPARK"
                                                                                                                                                                                      	DataSourceTypeSqlserver           DataSourceType = "SQLSERVER"
                                                                                                                                                                                      	DataSourceTypeTeradata            DataSourceType = "TERADATA"
                                                                                                                                                                                      	DataSourceTypeTwitter             DataSourceType = "TWITTER"
                                                                                                                                                                                      	DataSourceTypeTimestream          DataSourceType = "TIMESTREAM"
                                                                                                                                                                                      )

                                                                                                                                                                                        Enum values for DataSourceType

                                                                                                                                                                                        func (DataSourceType) Values

                                                                                                                                                                                        func (DataSourceType) Values() []DataSourceType

                                                                                                                                                                                          Values returns all known values for DataSourceType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                          type DateTimeParameter

                                                                                                                                                                                          type DateTimeParameter struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// A display name for the date-time parameter.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	Name *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// The values for the date-time parameter.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	Values []time.Time
                                                                                                                                                                                          }

                                                                                                                                                                                            A date-time parameter.

                                                                                                                                                                                            type DecimalParameter

                                                                                                                                                                                            type DecimalParameter struct {
                                                                                                                                                                                            
                                                                                                                                                                                            	// A display name for the decimal parameter.
                                                                                                                                                                                            	//
                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                            	Name *string
                                                                                                                                                                                            
                                                                                                                                                                                            	// The values for the decimal parameter.
                                                                                                                                                                                            	//
                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                            	Values []float64
                                                                                                                                                                                            }

                                                                                                                                                                                              A decimal parameter.

                                                                                                                                                                                              type DomainNotWhitelistedException

                                                                                                                                                                                              type DomainNotWhitelistedException struct {
                                                                                                                                                                                              	Message *string
                                                                                                                                                                                              
                                                                                                                                                                                              	RequestId *string
                                                                                                                                                                                              }

                                                                                                                                                                                                The domain specified isn't on the allow list. All domains for embedded dashboards must be added to the approved list by an Amazon QuickSight admin.

                                                                                                                                                                                                func (*DomainNotWhitelistedException) Error

                                                                                                                                                                                                func (*DomainNotWhitelistedException) ErrorCode

                                                                                                                                                                                                func (e *DomainNotWhitelistedException) ErrorCode() string

                                                                                                                                                                                                func (*DomainNotWhitelistedException) ErrorFault

                                                                                                                                                                                                func (*DomainNotWhitelistedException) ErrorMessage

                                                                                                                                                                                                func (e *DomainNotWhitelistedException) ErrorMessage() string

                                                                                                                                                                                                type Edition

                                                                                                                                                                                                type Edition string
                                                                                                                                                                                                const (
                                                                                                                                                                                                	EditionStandard   Edition = "STANDARD"
                                                                                                                                                                                                	EditionEnterprise Edition = "ENTERPRISE"
                                                                                                                                                                                                )

                                                                                                                                                                                                  Enum values for Edition

                                                                                                                                                                                                  func (Edition) Values

                                                                                                                                                                                                  func (Edition) Values() []Edition

                                                                                                                                                                                                    Values returns all known values for Edition. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                    type EmbeddingIdentityType

                                                                                                                                                                                                    type EmbeddingIdentityType string
                                                                                                                                                                                                    const (
                                                                                                                                                                                                    	EmbeddingIdentityTypeIam        EmbeddingIdentityType = "IAM"
                                                                                                                                                                                                    	EmbeddingIdentityTypeQuicksight EmbeddingIdentityType = "QUICKSIGHT"
                                                                                                                                                                                                    	EmbeddingIdentityTypeAnonymous  EmbeddingIdentityType = "ANONYMOUS"
                                                                                                                                                                                                    )

                                                                                                                                                                                                      Enum values for EmbeddingIdentityType

                                                                                                                                                                                                      func (EmbeddingIdentityType) Values

                                                                                                                                                                                                        Values returns all known values for EmbeddingIdentityType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                        type ErrorInfo

                                                                                                                                                                                                        type ErrorInfo struct {
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// Error message.
                                                                                                                                                                                                        	Message *string
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// Error type.
                                                                                                                                                                                                        	Type IngestionErrorType
                                                                                                                                                                                                        }

                                                                                                                                                                                                          Error information for the SPICE ingestion of a dataset.

                                                                                                                                                                                                          type ExceptionResourceType

                                                                                                                                                                                                          type ExceptionResourceType string
                                                                                                                                                                                                          const (
                                                                                                                                                                                                          	ExceptionResourceTypeUser                ExceptionResourceType = "USER"
                                                                                                                                                                                                          	ExceptionResourceTypeGroup               ExceptionResourceType = "GROUP"
                                                                                                                                                                                                          	ExceptionResourceTypeNamespace           ExceptionResourceType = "NAMESPACE"
                                                                                                                                                                                                          	ExceptionResourceTypeAccountSettings     ExceptionResourceType = "ACCOUNT_SETTINGS"
                                                                                                                                                                                                          	ExceptionResourceTypeIampolicyAssignment ExceptionResourceType = "IAMPOLICY_ASSIGNMENT"
                                                                                                                                                                                                          	ExceptionResourceTypeDataSource          ExceptionResourceType = "DATA_SOURCE"
                                                                                                                                                                                                          	ExceptionResourceTypeDataSet             ExceptionResourceType = "DATA_SET"
                                                                                                                                                                                                          	ExceptionResourceTypeVpcConnection       ExceptionResourceType = "VPC_CONNECTION"
                                                                                                                                                                                                          	ExceptionResourceTypeIngestion           ExceptionResourceType = "INGESTION"
                                                                                                                                                                                                          )

                                                                                                                                                                                                            Enum values for ExceptionResourceType

                                                                                                                                                                                                            func (ExceptionResourceType) Values

                                                                                                                                                                                                              Values returns all known values for ExceptionResourceType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                              type ExportToCSVOption

                                                                                                                                                                                                              type ExportToCSVOption struct {
                                                                                                                                                                                                              
                                                                                                                                                                                                              	// Availability status.
                                                                                                                                                                                                              	AvailabilityStatus DashboardBehavior
                                                                                                                                                                                                              }

                                                                                                                                                                                                                Export to .csv option.

                                                                                                                                                                                                                type FieldFolder

                                                                                                                                                                                                                type FieldFolder struct {
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// A folder has a list of columns. A column can only be in one folder.
                                                                                                                                                                                                                	Columns []string
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// The description for a field folder.
                                                                                                                                                                                                                	Description *string
                                                                                                                                                                                                                }

                                                                                                                                                                                                                  A FieldFolder element is a folder that contains fields and nested subfolders.

                                                                                                                                                                                                                  type FileFormat

                                                                                                                                                                                                                  type FileFormat string
                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                  	FileFormatCsv  FileFormat = "CSV"
                                                                                                                                                                                                                  	FileFormatTsv  FileFormat = "TSV"
                                                                                                                                                                                                                  	FileFormatClf  FileFormat = "CLF"
                                                                                                                                                                                                                  	FileFormatElf  FileFormat = "ELF"
                                                                                                                                                                                                                  	FileFormatXlsx FileFormat = "XLSX"
                                                                                                                                                                                                                  	FileFormatJson FileFormat = "JSON"
                                                                                                                                                                                                                  )

                                                                                                                                                                                                                    Enum values for FileFormat

                                                                                                                                                                                                                    func (FileFormat) Values

                                                                                                                                                                                                                    func (FileFormat) Values() []FileFormat

                                                                                                                                                                                                                      Values returns all known values for FileFormat. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                      type FilterOperation

                                                                                                                                                                                                                      type FilterOperation struct {
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// An expression that must evaluate to a Boolean value. Rows for which the
                                                                                                                                                                                                                      	// expression evaluates to true are kept in the dataset.
                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                      	ConditionExpression *string
                                                                                                                                                                                                                      }

                                                                                                                                                                                                                        A transform operation that filters rows based on a condition.

                                                                                                                                                                                                                        type FilterOperator

                                                                                                                                                                                                                        type FilterOperator string
                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                        	FilterOperatorStringEquals FilterOperator = "StringEquals"
                                                                                                                                                                                                                        )

                                                                                                                                                                                                                          Enum values for FilterOperator

                                                                                                                                                                                                                          func (FilterOperator) Values

                                                                                                                                                                                                                          func (FilterOperator) Values() []FilterOperator

                                                                                                                                                                                                                            Values returns all known values for FilterOperator. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                            type GeoSpatialColumnGroup

                                                                                                                                                                                                                            type GeoSpatialColumnGroup struct {
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// Columns in this hierarchy.
                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                            	Columns []string
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// Country code.
                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                            	CountryCode GeoSpatialCountryCode
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// A display name for the hierarchy.
                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                            	Name *string
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                              Geospatial column group that denotes a hierarchy.

                                                                                                                                                                                                                              type GeoSpatialCountryCode

                                                                                                                                                                                                                              type GeoSpatialCountryCode string
                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                              	GeoSpatialCountryCodeUs GeoSpatialCountryCode = "US"
                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                Enum values for GeoSpatialCountryCode

                                                                                                                                                                                                                                func (GeoSpatialCountryCode) Values

                                                                                                                                                                                                                                  Values returns all known values for GeoSpatialCountryCode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                  type GeoSpatialDataRole

                                                                                                                                                                                                                                  type GeoSpatialDataRole string
                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                  	GeoSpatialDataRoleCountry   GeoSpatialDataRole = "COUNTRY"
                                                                                                                                                                                                                                  	GeoSpatialDataRoleState     GeoSpatialDataRole = "STATE"
                                                                                                                                                                                                                                  	GeoSpatialDataRoleCounty    GeoSpatialDataRole = "COUNTY"
                                                                                                                                                                                                                                  	GeoSpatialDataRoleCity      GeoSpatialDataRole = "CITY"
                                                                                                                                                                                                                                  	GeoSpatialDataRolePostcode  GeoSpatialDataRole = "POSTCODE"
                                                                                                                                                                                                                                  	GeoSpatialDataRoleLongitude GeoSpatialDataRole = "LONGITUDE"
                                                                                                                                                                                                                                  	GeoSpatialDataRoleLatitude  GeoSpatialDataRole = "LATITUDE"
                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                    Enum values for GeoSpatialDataRole

                                                                                                                                                                                                                                    func (GeoSpatialDataRole) Values

                                                                                                                                                                                                                                      Values returns all known values for GeoSpatialDataRole. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                      type Group

                                                                                                                                                                                                                                      type Group struct {
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The Amazon Resource Name (ARN) for the group.
                                                                                                                                                                                                                                      	Arn *string
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The group description.
                                                                                                                                                                                                                                      	Description *string
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The name of the group.
                                                                                                                                                                                                                                      	GroupName *string
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The principal ID of the group.
                                                                                                                                                                                                                                      	PrincipalId *string
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                        A group in Amazon QuickSight consists of a set of users. You can use groups to make it easier to manage access and security.

                                                                                                                                                                                                                                        type GroupMember

                                                                                                                                                                                                                                        type GroupMember struct {
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// The Amazon Resource Name (ARN) for the group member (user).
                                                                                                                                                                                                                                        	Arn *string
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// The name of the group member (user).
                                                                                                                                                                                                                                        	MemberName *string
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                          A member of an Amazon QuickSight group. Currently, group members must be users. Groups can't be members of another group. .

                                                                                                                                                                                                                                          type GutterStyle

                                                                                                                                                                                                                                          type GutterStyle struct {
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// This Boolean value controls whether to display a gutter space between sheet
                                                                                                                                                                                                                                          	// tiles.
                                                                                                                                                                                                                                          	Show bool
                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                            The display options for gutter spacing between tiles on a sheet.

                                                                                                                                                                                                                                            type IAMPolicyAssignment

                                                                                                                                                                                                                                            type IAMPolicyAssignment struct {
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// Assignment ID.
                                                                                                                                                                                                                                            	AssignmentId *string
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// Assignment name.
                                                                                                                                                                                                                                            	AssignmentName *string
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// Assignment status.
                                                                                                                                                                                                                                            	AssignmentStatus AssignmentStatus
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// The AWS account ID.
                                                                                                                                                                                                                                            	AwsAccountId *string
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// Identities.
                                                                                                                                                                                                                                            	Identities map[string][]string
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// The Amazon Resource Name (ARN) for the IAM policy.
                                                                                                                                                                                                                                            	PolicyArn *string
                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                              An AWS Identity and Access Management (IAM) policy assignment.

                                                                                                                                                                                                                                              type IAMPolicyAssignmentSummary

                                                                                                                                                                                                                                              type IAMPolicyAssignmentSummary struct {
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// Assignment name.
                                                                                                                                                                                                                                              	AssignmentName *string
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// Assignment status.
                                                                                                                                                                                                                                              	AssignmentStatus AssignmentStatus
                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                IAM policy assignment summary.

                                                                                                                                                                                                                                                type IdentityStore

                                                                                                                                                                                                                                                type IdentityStore string
                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                	IdentityStoreQuicksight IdentityStore = "QUICKSIGHT"
                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                  Enum values for IdentityStore

                                                                                                                                                                                                                                                  func (IdentityStore) Values

                                                                                                                                                                                                                                                  func (IdentityStore) Values() []IdentityStore

                                                                                                                                                                                                                                                    Values returns all known values for IdentityStore. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                    type IdentityType

                                                                                                                                                                                                                                                    type IdentityType string
                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                    	IdentityTypeIam        IdentityType = "IAM"
                                                                                                                                                                                                                                                    	IdentityTypeQuicksight IdentityType = "QUICKSIGHT"
                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                      Enum values for IdentityType

                                                                                                                                                                                                                                                      func (IdentityType) Values

                                                                                                                                                                                                                                                      func (IdentityType) Values() []IdentityType

                                                                                                                                                                                                                                                        Values returns all known values for IdentityType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                        type IdentityTypeNotSupportedException

                                                                                                                                                                                                                                                        type IdentityTypeNotSupportedException struct {
                                                                                                                                                                                                                                                        	Message *string
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	RequestId *string
                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                          The identity type specified isn't supported. Supported identity types include IAM and QUICKSIGHT.

                                                                                                                                                                                                                                                          func (*IdentityTypeNotSupportedException) Error

                                                                                                                                                                                                                                                          func (*IdentityTypeNotSupportedException) ErrorCode

                                                                                                                                                                                                                                                          func (*IdentityTypeNotSupportedException) ErrorFault

                                                                                                                                                                                                                                                          func (*IdentityTypeNotSupportedException) ErrorMessage

                                                                                                                                                                                                                                                          func (e *IdentityTypeNotSupportedException) ErrorMessage() string

                                                                                                                                                                                                                                                          type Ingestion

                                                                                                                                                                                                                                                          type Ingestion struct {
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The Amazon Resource Name (ARN) of the resource.
                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                          	Arn *string
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The time that this ingestion started.
                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                          	CreatedTime *time.Time
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// Ingestion status.
                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                          	IngestionStatus IngestionStatus
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// Error information for this ingestion.
                                                                                                                                                                                                                                                          	ErrorInfo *ErrorInfo
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// Ingestion ID.
                                                                                                                                                                                                                                                          	IngestionId *string
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The size of the data ingested, in bytes.
                                                                                                                                                                                                                                                          	IngestionSizeInBytes int64
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The time that this ingestion took, measured in seconds.
                                                                                                                                                                                                                                                          	IngestionTimeInSeconds int64
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// Information about a queued dataset SPICE ingestion.
                                                                                                                                                                                                                                                          	QueueInfo *QueueInfo
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// Event source for this ingestion.
                                                                                                                                                                                                                                                          	RequestSource IngestionRequestSource
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// Type of this ingestion.
                                                                                                                                                                                                                                                          	RequestType IngestionRequestType
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// Information about rows for a data set SPICE ingestion.
                                                                                                                                                                                                                                                          	RowInfo *RowInfo
                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                            Information about the SPICE ingestion for a dataset.

                                                                                                                                                                                                                                                            type IngestionErrorType

                                                                                                                                                                                                                                                            type IngestionErrorType string
                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                            	IngestionErrorTypeFailureToAssumeRole             IngestionErrorType = "FAILURE_TO_ASSUME_ROLE"
                                                                                                                                                                                                                                                            	IngestionErrorTypeIngestionSuperseded             IngestionErrorType = "INGESTION_SUPERSEDED"
                                                                                                                                                                                                                                                            	IngestionErrorTypeIngestionCanceled               IngestionErrorType = "INGESTION_CANCELED"
                                                                                                                                                                                                                                                            	IngestionErrorTypeDataSetDeleted                  IngestionErrorType = "DATA_SET_DELETED"
                                                                                                                                                                                                                                                            	IngestionErrorTypeDataSetNotSpice                 IngestionErrorType = "DATA_SET_NOT_SPICE"
                                                                                                                                                                                                                                                            	IngestionErrorTypeS3UploadedFileDeleted           IngestionErrorType = "S3_UPLOADED_FILE_DELETED"
                                                                                                                                                                                                                                                            	IngestionErrorTypeS3ManifestError                 IngestionErrorType = "S3_MANIFEST_ERROR"
                                                                                                                                                                                                                                                            	IngestionErrorTypeDataToleranceException          IngestionErrorType = "DATA_TOLERANCE_EXCEPTION"
                                                                                                                                                                                                                                                            	IngestionErrorTypeSpiceTableNotFound              IngestionErrorType = "SPICE_TABLE_NOT_FOUND"
                                                                                                                                                                                                                                                            	IngestionErrorTypeDataSetSizeLimitExceeded        IngestionErrorType = "DATA_SET_SIZE_LIMIT_EXCEEDED"
                                                                                                                                                                                                                                                            	IngestionErrorTypeRowSizeLimitExceeded            IngestionErrorType = "ROW_SIZE_LIMIT_EXCEEDED"
                                                                                                                                                                                                                                                            	IngestionErrorTypeAccountCapacityLimitExceeded    IngestionErrorType = "ACCOUNT_CAPACITY_LIMIT_EXCEEDED"
                                                                                                                                                                                                                                                            	IngestionErrorTypeCustomerError                   IngestionErrorType = "CUSTOMER_ERROR"
                                                                                                                                                                                                                                                            	IngestionErrorTypeDataSourceNotFound              IngestionErrorType = "DATA_SOURCE_NOT_FOUND"
                                                                                                                                                                                                                                                            	IngestionErrorTypeIamRoleNotAvailable             IngestionErrorType = "IAM_ROLE_NOT_AVAILABLE"
                                                                                                                                                                                                                                                            	IngestionErrorTypeConnectionFailure               IngestionErrorType = "CONNECTION_FAILURE"
                                                                                                                                                                                                                                                            	IngestionErrorTypeSqlTableNotFound                IngestionErrorType = "SQL_TABLE_NOT_FOUND"
                                                                                                                                                                                                                                                            	IngestionErrorTypePermissionDenied                IngestionErrorType = "PERMISSION_DENIED"
                                                                                                                                                                                                                                                            	IngestionErrorTypeSslCertificateValidationFailure IngestionErrorType = "SSL_CERTIFICATE_VALIDATION_FAILURE"
                                                                                                                                                                                                                                                            	IngestionErrorTypeOauthTokenFailure               IngestionErrorType = "OAUTH_TOKEN_FAILURE"
                                                                                                                                                                                                                                                            	IngestionErrorTypeSourceApiLimitExceededFailure   IngestionErrorType = "SOURCE_API_LIMIT_EXCEEDED_FAILURE"
                                                                                                                                                                                                                                                            	IngestionErrorTypePasswordAuthenticationFailure   IngestionErrorType = "PASSWORD_AUTHENTICATION_FAILURE"
                                                                                                                                                                                                                                                            	IngestionErrorTypeSqlSchemaMismatchError          IngestionErrorType = "SQL_SCHEMA_MISMATCH_ERROR"
                                                                                                                                                                                                                                                            	IngestionErrorTypeInvalidDateFormat               IngestionErrorType = "INVALID_DATE_FORMAT"
                                                                                                                                                                                                                                                            	IngestionErrorTypeInvalidDataprepSyntax           IngestionErrorType = "INVALID_DATAPREP_SYNTAX"
                                                                                                                                                                                                                                                            	IngestionErrorTypeSourceResourceLimitExceeded     IngestionErrorType = "SOURCE_RESOURCE_LIMIT_EXCEEDED"
                                                                                                                                                                                                                                                            	IngestionErrorTypeSqlInvalidParameterValue        IngestionErrorType = "SQL_INVALID_PARAMETER_VALUE"
                                                                                                                                                                                                                                                            	IngestionErrorTypeQueryTimeout                    IngestionErrorType = "QUERY_TIMEOUT"
                                                                                                                                                                                                                                                            	IngestionErrorTypeSqlNumericOverflow              IngestionErrorType = "SQL_NUMERIC_OVERFLOW"
                                                                                                                                                                                                                                                            	IngestionErrorTypeUnresolvableHost                IngestionErrorType = "UNRESOLVABLE_HOST"
                                                                                                                                                                                                                                                            	IngestionErrorTypeUnroutableHost                  IngestionErrorType = "UNROUTABLE_HOST"
                                                                                                                                                                                                                                                            	IngestionErrorTypeSqlException                    IngestionErrorType = "SQL_EXCEPTION"
                                                                                                                                                                                                                                                            	IngestionErrorTypeS3FileInaccessible              IngestionErrorType = "S3_FILE_INACCESSIBLE"
                                                                                                                                                                                                                                                            	IngestionErrorTypeIotFileNotFound                 IngestionErrorType = "IOT_FILE_NOT_FOUND"
                                                                                                                                                                                                                                                            	IngestionErrorTypeIotDataSetFileEmpty             IngestionErrorType = "IOT_DATA_SET_FILE_EMPTY"
                                                                                                                                                                                                                                                            	IngestionErrorTypeInvalidDataSourceConfig         IngestionErrorType = "INVALID_DATA_SOURCE_CONFIG"
                                                                                                                                                                                                                                                            	IngestionErrorTypeDataSourceAuthFailed            IngestionErrorType = "DATA_SOURCE_AUTH_FAILED"
                                                                                                                                                                                                                                                            	IngestionErrorTypeDataSourceConnectionFailed      IngestionErrorType = "DATA_SOURCE_CONNECTION_FAILED"
                                                                                                                                                                                                                                                            	IngestionErrorTypeFailureToProcessJsonFile        IngestionErrorType = "FAILURE_TO_PROCESS_JSON_FILE"
                                                                                                                                                                                                                                                            	IngestionErrorTypeInternalServiceError            IngestionErrorType = "INTERNAL_SERVICE_ERROR"
                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                              Enum values for IngestionErrorType

                                                                                                                                                                                                                                                              func (IngestionErrorType) Values

                                                                                                                                                                                                                                                                Values returns all known values for IngestionErrorType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                type IngestionRequestSource

                                                                                                                                                                                                                                                                type IngestionRequestSource string
                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                	IngestionRequestSourceManual    IngestionRequestSource = "MANUAL"
                                                                                                                                                                                                                                                                	IngestionRequestSourceScheduled IngestionRequestSource = "SCHEDULED"
                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                  Enum values for IngestionRequestSource

                                                                                                                                                                                                                                                                  func (IngestionRequestSource) Values

                                                                                                                                                                                                                                                                    Values returns all known values for IngestionRequestSource. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                    type IngestionRequestType

                                                                                                                                                                                                                                                                    type IngestionRequestType string
                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                    	IngestionRequestTypeInitialIngestion   IngestionRequestType = "INITIAL_INGESTION"
                                                                                                                                                                                                                                                                    	IngestionRequestTypeEdit               IngestionRequestType = "EDIT"
                                                                                                                                                                                                                                                                    	IngestionRequestTypeIncrementalRefresh IngestionRequestType = "INCREMENTAL_REFRESH"
                                                                                                                                                                                                                                                                    	IngestionRequestTypeFullRefresh        IngestionRequestType = "FULL_REFRESH"
                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                      Enum values for IngestionRequestType

                                                                                                                                                                                                                                                                      func (IngestionRequestType) Values

                                                                                                                                                                                                                                                                        Values returns all known values for IngestionRequestType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                        type IngestionStatus

                                                                                                                                                                                                                                                                        type IngestionStatus string
                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                        	IngestionStatusInitialized IngestionStatus = "INITIALIZED"
                                                                                                                                                                                                                                                                        	IngestionStatusQueued      IngestionStatus = "QUEUED"
                                                                                                                                                                                                                                                                        	IngestionStatusRunning     IngestionStatus = "RUNNING"
                                                                                                                                                                                                                                                                        	IngestionStatusFailed      IngestionStatus = "FAILED"
                                                                                                                                                                                                                                                                        	IngestionStatusCompleted   IngestionStatus = "COMPLETED"
                                                                                                                                                                                                                                                                        	IngestionStatusCancelled   IngestionStatus = "CANCELLED"
                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                          Enum values for IngestionStatus

                                                                                                                                                                                                                                                                          func (IngestionStatus) Values

                                                                                                                                                                                                                                                                          func (IngestionStatus) Values() []IngestionStatus

                                                                                                                                                                                                                                                                            Values returns all known values for IngestionStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                            type InputColumn

                                                                                                                                                                                                                                                                            type InputColumn struct {
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// The name of this column in the underlying data source.
                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                            	Name *string
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// The data type of the column.
                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                            	Type InputColumnDataType
                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                              Metadata for a column that is used as the input of a transform operation.

                                                                                                                                                                                                                                                                              type InputColumnDataType

                                                                                                                                                                                                                                                                              type InputColumnDataType string
                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                              	InputColumnDataTypeString   InputColumnDataType = "STRING"
                                                                                                                                                                                                                                                                              	InputColumnDataTypeInteger  InputColumnDataType = "INTEGER"
                                                                                                                                                                                                                                                                              	InputColumnDataTypeDecimal  InputColumnDataType = "DECIMAL"
                                                                                                                                                                                                                                                                              	InputColumnDataTypeDatetime InputColumnDataType = "DATETIME"
                                                                                                                                                                                                                                                                              	InputColumnDataTypeBit      InputColumnDataType = "BIT"
                                                                                                                                                                                                                                                                              	InputColumnDataTypeBoolean  InputColumnDataType = "BOOLEAN"
                                                                                                                                                                                                                                                                              	InputColumnDataTypeJson     InputColumnDataType = "JSON"
                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                Enum values for InputColumnDataType

                                                                                                                                                                                                                                                                                func (InputColumnDataType) Values

                                                                                                                                                                                                                                                                                  Values returns all known values for InputColumnDataType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                  type IntegerParameter

                                                                                                                                                                                                                                                                                  type IntegerParameter struct {
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// The name of the integer parameter.
                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                  	Name *string
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// The values for the integer parameter.
                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                  	Values []int64
                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                    An integer parameter.

                                                                                                                                                                                                                                                                                    type InternalFailureException

                                                                                                                                                                                                                                                                                    type InternalFailureException struct {
                                                                                                                                                                                                                                                                                    	Message *string
                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                    	RequestId *string
                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                      An internal failure occurred.

                                                                                                                                                                                                                                                                                      func (*InternalFailureException) Error

                                                                                                                                                                                                                                                                                      func (e *InternalFailureException) Error() string

                                                                                                                                                                                                                                                                                      func (*InternalFailureException) ErrorCode

                                                                                                                                                                                                                                                                                      func (e *InternalFailureException) ErrorCode() string

                                                                                                                                                                                                                                                                                      func (*InternalFailureException) ErrorFault

                                                                                                                                                                                                                                                                                      func (e *InternalFailureException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                      func (*InternalFailureException) ErrorMessage

                                                                                                                                                                                                                                                                                      func (e *InternalFailureException) ErrorMessage() string

                                                                                                                                                                                                                                                                                      type InvalidNextTokenException

                                                                                                                                                                                                                                                                                      type InvalidNextTokenException struct {
                                                                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                      	RequestId *string
                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                        The NextToken value isn't valid.

                                                                                                                                                                                                                                                                                        func (*InvalidNextTokenException) Error

                                                                                                                                                                                                                                                                                        func (e *InvalidNextTokenException) Error() string

                                                                                                                                                                                                                                                                                        func (*InvalidNextTokenException) ErrorCode

                                                                                                                                                                                                                                                                                        func (e *InvalidNextTokenException) ErrorCode() string

                                                                                                                                                                                                                                                                                        func (*InvalidNextTokenException) ErrorFault

                                                                                                                                                                                                                                                                                        func (*InvalidNextTokenException) ErrorMessage

                                                                                                                                                                                                                                                                                        func (e *InvalidNextTokenException) ErrorMessage() string

                                                                                                                                                                                                                                                                                        type InvalidParameterValueException

                                                                                                                                                                                                                                                                                        type InvalidParameterValueException struct {
                                                                                                                                                                                                                                                                                        	Message *string
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	RequestId *string
                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                          One or more parameters has a value that isn't valid.

                                                                                                                                                                                                                                                                                          func (*InvalidParameterValueException) Error

                                                                                                                                                                                                                                                                                          func (*InvalidParameterValueException) ErrorCode

                                                                                                                                                                                                                                                                                          func (e *InvalidParameterValueException) ErrorCode() string

                                                                                                                                                                                                                                                                                          func (*InvalidParameterValueException) ErrorFault

                                                                                                                                                                                                                                                                                          func (*InvalidParameterValueException) ErrorMessage

                                                                                                                                                                                                                                                                                          func (e *InvalidParameterValueException) ErrorMessage() string

                                                                                                                                                                                                                                                                                          type JiraParameters

                                                                                                                                                                                                                                                                                          type JiraParameters struct {
                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                          	// The base URL of the Jira site.
                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                          	SiteBaseUrl *string
                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                            Jira parameters.

                                                                                                                                                                                                                                                                                            type JoinInstruction

                                                                                                                                                                                                                                                                                            type JoinInstruction struct {
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// The operand on the left side of a join.
                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                            	LeftOperand *string
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// The join instructions provided in the ON clause of a join.
                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                            	OnClause *string
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// The operand on the right side of a join.
                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                            	RightOperand *string
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// The type of join that it is.
                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                            	Type JoinType
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// Join key properties of the left operand.
                                                                                                                                                                                                                                                                                            	LeftJoinKeyProperties *JoinKeyProperties
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// Join key properties of the right operand.
                                                                                                                                                                                                                                                                                            	RightJoinKeyProperties *JoinKeyProperties
                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                              The instructions associated with a join.

                                                                                                                                                                                                                                                                                              type JoinKeyProperties

                                                                                                                                                                                                                                                                                              type JoinKeyProperties struct {
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              	// A value that indicates that a row in a table is uniquely identified by the
                                                                                                                                                                                                                                                                                              	// columns in a join key. This is used by QuickSight to optimize query performance.
                                                                                                                                                                                                                                                                                              	UniqueKey bool
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                Properties associated with the columns participating in a join.

                                                                                                                                                                                                                                                                                                type JoinType

                                                                                                                                                                                                                                                                                                type JoinType string
                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                	JoinTypeInner JoinType = "INNER"
                                                                                                                                                                                                                                                                                                	JoinTypeOuter JoinType = "OUTER"
                                                                                                                                                                                                                                                                                                	JoinTypeLeft  JoinType = "LEFT"
                                                                                                                                                                                                                                                                                                	JoinTypeRight JoinType = "RIGHT"
                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                  Enum values for JoinType

                                                                                                                                                                                                                                                                                                  func (JoinType) Values

                                                                                                                                                                                                                                                                                                  func (JoinType) Values() []JoinType

                                                                                                                                                                                                                                                                                                    Values returns all known values for JoinType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                    type LimitExceededException

                                                                                                                                                                                                                                                                                                    type LimitExceededException struct {
                                                                                                                                                                                                                                                                                                    	Message *string
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	ResourceType ExceptionResourceType
                                                                                                                                                                                                                                                                                                    	RequestId    *string
                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                      A limit is exceeded.

                                                                                                                                                                                                                                                                                                      func (*LimitExceededException) Error

                                                                                                                                                                                                                                                                                                      func (e *LimitExceededException) Error() string

                                                                                                                                                                                                                                                                                                      func (*LimitExceededException) ErrorCode

                                                                                                                                                                                                                                                                                                      func (e *LimitExceededException) ErrorCode() string

                                                                                                                                                                                                                                                                                                      func (*LimitExceededException) ErrorFault

                                                                                                                                                                                                                                                                                                      func (e *LimitExceededException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                                      func (*LimitExceededException) ErrorMessage

                                                                                                                                                                                                                                                                                                      func (e *LimitExceededException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                      type LogicalTable

                                                                                                                                                                                                                                                                                                      type LogicalTable struct {
                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                      	// A display name for the logical table.
                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                      	Alias *string
                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                      	// Source of this logical table.
                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                      	Source *LogicalTableSource
                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                      	// Transform operations that act on this logical table.
                                                                                                                                                                                                                                                                                                      	DataTransforms []TransformOperation
                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                        A logical table is a unit that joins and that data transformations operate on. A logical table has a source, which can be either a physical table or result of a join. When a logical table points to a physical table, the logical table acts as a mutable copy of that physical table through transform operations.

                                                                                                                                                                                                                                                                                                        type LogicalTableSource

                                                                                                                                                                                                                                                                                                        type LogicalTableSource struct {
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// Specifies the result of a join of two logical tables.
                                                                                                                                                                                                                                                                                                        	JoinInstruction *JoinInstruction
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// Physical table ID.
                                                                                                                                                                                                                                                                                                        	PhysicalTableId *string
                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                          Information about the source of a logical table. This is a variant type structure. For this structure to be valid, only one of the attributes can be non-null.

                                                                                                                                                                                                                                                                                                          type ManifestFileLocation

                                                                                                                                                                                                                                                                                                          type ManifestFileLocation struct {
                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                          	// Amazon S3 bucket.
                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                          	Bucket *string
                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                          	// Amazon S3 key that identifies an object.
                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                          	Key *string
                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                            Amazon S3 manifest file location.

                                                                                                                                                                                                                                                                                                            type MarginStyle

                                                                                                                                                                                                                                                                                                            type MarginStyle struct {
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// This Boolean value controls whether to display sheet margins.
                                                                                                                                                                                                                                                                                                            	Show bool
                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                              The display options for margins around the outside edge of sheets.

                                                                                                                                                                                                                                                                                                              type MariaDbParameters

                                                                                                                                                                                                                                                                                                              type MariaDbParameters struct {
                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                              	// Database.
                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                              	Database *string
                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                              	// Host.
                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                              	Host *string
                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                              	// Port.
                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                              	Port int32
                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                MariaDB parameters.

                                                                                                                                                                                                                                                                                                                type MySqlParameters

                                                                                                                                                                                                                                                                                                                type MySqlParameters struct {
                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                	// Database.
                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                	Database *string
                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                	// Host.
                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                	Host *string
                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                	// Port.
                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                	Port int32
                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                  MySQL parameters.

                                                                                                                                                                                                                                                                                                                  type NamespaceError

                                                                                                                                                                                                                                                                                                                  type NamespaceError struct {
                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                  	// The message for the error.
                                                                                                                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                  	// The error type.
                                                                                                                                                                                                                                                                                                                  	Type NamespaceErrorType
                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                    Errors that occur during namespace creation.

                                                                                                                                                                                                                                                                                                                    type NamespaceErrorType

                                                                                                                                                                                                                                                                                                                    type NamespaceErrorType string
                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                    	NamespaceErrorTypePermissionDenied     NamespaceErrorType = "PERMISSION_DENIED"
                                                                                                                                                                                                                                                                                                                    	NamespaceErrorTypeInternalServiceError NamespaceErrorType = "INTERNAL_SERVICE_ERROR"
                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                      Enum values for NamespaceErrorType

                                                                                                                                                                                                                                                                                                                      func (NamespaceErrorType) Values

                                                                                                                                                                                                                                                                                                                        Values returns all known values for NamespaceErrorType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                        type NamespaceInfoV2

                                                                                                                                                                                                                                                                                                                        type NamespaceInfoV2 struct {
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The namespace ARN.
                                                                                                                                                                                                                                                                                                                        	Arn *string
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The namespace AWS Region.
                                                                                                                                                                                                                                                                                                                        	CapacityRegion *string
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The creation status of a namespace that is not yet completely created.
                                                                                                                                                                                                                                                                                                                        	CreationStatus NamespaceStatus
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The identity store used for the namespace.
                                                                                                                                                                                                                                                                                                                        	IdentityStore IdentityStore
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The name of the error.
                                                                                                                                                                                                                                                                                                                        	Name *string
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// An error that occurred when the namespace was created.
                                                                                                                                                                                                                                                                                                                        	NamespaceError *NamespaceError
                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                          The error type.

                                                                                                                                                                                                                                                                                                                          type NamespaceStatus

                                                                                                                                                                                                                                                                                                                          type NamespaceStatus string
                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                          	NamespaceStatusCreated             NamespaceStatus = "CREATED"
                                                                                                                                                                                                                                                                                                                          	NamespaceStatusCreating            NamespaceStatus = "CREATING"
                                                                                                                                                                                                                                                                                                                          	NamespaceStatusDeleting            NamespaceStatus = "DELETING"
                                                                                                                                                                                                                                                                                                                          	NamespaceStatusRetryableFailure    NamespaceStatus = "RETRYABLE_FAILURE"
                                                                                                                                                                                                                                                                                                                          	NamespaceStatusNonRetryableFailure NamespaceStatus = "NON_RETRYABLE_FAILURE"
                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                            Enum values for NamespaceStatus

                                                                                                                                                                                                                                                                                                                            func (NamespaceStatus) Values

                                                                                                                                                                                                                                                                                                                            func (NamespaceStatus) Values() []NamespaceStatus

                                                                                                                                                                                                                                                                                                                              Values returns all known values for NamespaceStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                              type OracleParameters

                                                                                                                                                                                                                                                                                                                              type OracleParameters struct {
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// Database.
                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                              	Database *string
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// An Oracle host.
                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                              	Host *string
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// Port.
                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                              	Port int32
                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                Oracle parameters.

                                                                                                                                                                                                                                                                                                                                type OutputColumn

                                                                                                                                                                                                                                                                                                                                type OutputColumn struct {
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// A description for a column.
                                                                                                                                                                                                                                                                                                                                	Description *string
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// A display name for the dataset.
                                                                                                                                                                                                                                                                                                                                	Name *string
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// Type.
                                                                                                                                                                                                                                                                                                                                	Type ColumnDataType
                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                  Output column.

                                                                                                                                                                                                                                                                                                                                  type Parameters

                                                                                                                                                                                                                                                                                                                                  type Parameters struct {
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// Date-time parameters.
                                                                                                                                                                                                                                                                                                                                  	DateTimeParameters []DateTimeParameter
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// Decimal parameters.
                                                                                                                                                                                                                                                                                                                                  	DecimalParameters []DecimalParameter
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// Integer parameters.
                                                                                                                                                                                                                                                                                                                                  	IntegerParameters []IntegerParameter
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// String parameters.
                                                                                                                                                                                                                                                                                                                                  	StringParameters []StringParameter
                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                    A list of QuickSight parameters and the list's override values.

                                                                                                                                                                                                                                                                                                                                    type PhysicalTable

                                                                                                                                                                                                                                                                                                                                    type PhysicalTable interface {
                                                                                                                                                                                                                                                                                                                                    	// contains filtered or unexported methods
                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                      A view of a data source that contains information about the shape of the data in the underlying source. This is a variant type structure. For this structure to be valid, only one of the attributes can be non-null.

                                                                                                                                                                                                                                                                                                                                      The following types satisfy this interface:

                                                                                                                                                                                                                                                                                                                                      PhysicalTableMemberRelationalTable
                                                                                                                                                                                                                                                                                                                                      PhysicalTableMemberCustomSql
                                                                                                                                                                                                                                                                                                                                      PhysicalTableMemberS3Source
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      Example (OutputUsage)
                                                                                                                                                                                                                                                                                                                                      Output:
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                      type PhysicalTableMemberCustomSql

                                                                                                                                                                                                                                                                                                                                      type PhysicalTableMemberCustomSql struct {
                                                                                                                                                                                                                                                                                                                                      	Value CustomSql
                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                        A physical table type built from the results of the custom SQL query.

                                                                                                                                                                                                                                                                                                                                        type PhysicalTableMemberRelationalTable

                                                                                                                                                                                                                                                                                                                                        type PhysicalTableMemberRelationalTable struct {
                                                                                                                                                                                                                                                                                                                                        	Value RelationalTable
                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                          A physical table type for relational data sources.

                                                                                                                                                                                                                                                                                                                                          type PhysicalTableMemberS3Source

                                                                                                                                                                                                                                                                                                                                          type PhysicalTableMemberS3Source struct {
                                                                                                                                                                                                                                                                                                                                          	Value S3Source
                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                            A physical table type for as S3 data source.

                                                                                                                                                                                                                                                                                                                                            type PostgreSqlParameters

                                                                                                                                                                                                                                                                                                                                            type PostgreSqlParameters struct {
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// Database.
                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                                            	Database *string
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// Host.
                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                                            	Host *string
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// Port.
                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                                            	Port int32
                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                              PostgreSQL parameters.

                                                                                                                                                                                                                                                                                                                                              type PreconditionNotMetException

                                                                                                                                                                                                                                                                                                                                              type PreconditionNotMetException struct {
                                                                                                                                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                              	RequestId *string
                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                One or more preconditions aren't met.

                                                                                                                                                                                                                                                                                                                                                func (*PreconditionNotMetException) Error

                                                                                                                                                                                                                                                                                                                                                func (*PreconditionNotMetException) ErrorCode

                                                                                                                                                                                                                                                                                                                                                func (e *PreconditionNotMetException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                func (*PreconditionNotMetException) ErrorFault

                                                                                                                                                                                                                                                                                                                                                func (*PreconditionNotMetException) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                func (e *PreconditionNotMetException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                type PrestoParameters

                                                                                                                                                                                                                                                                                                                                                type PrestoParameters struct {
                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                	// Catalog.
                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                                                	Catalog *string
                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                	// Host.
                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                                                	Host *string
                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                	// Port.
                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                                                	Port int32
                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                  Presto parameters.

                                                                                                                                                                                                                                                                                                                                                  type ProjectOperation

                                                                                                                                                                                                                                                                                                                                                  type ProjectOperation struct {
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// Projected columns.
                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                  	ProjectedColumns []string
                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                    A transform operation that projects columns. Operations that come after a projection can only refer to projected columns.

                                                                                                                                                                                                                                                                                                                                                    type QueueInfo

                                                                                                                                                                                                                                                                                                                                                    type QueueInfo struct {
                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                    	// The ID of the ongoing ingestion. The queued ingestion is waiting for the ongoing
                                                                                                                                                                                                                                                                                                                                                    	// ingestion to complete.
                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                                    	QueuedIngestion *string
                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                    	// The ID of the queued ingestion.
                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                                    	WaitingOnIngestion *string
                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                      Information about a queued dataset SPICE ingestion.

                                                                                                                                                                                                                                                                                                                                                      type QuickSightUserNotFoundException

                                                                                                                                                                                                                                                                                                                                                      type QuickSightUserNotFoundException struct {
                                                                                                                                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                      	RequestId *string
                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                        The user with the provided name isn't found. This error can happen in any operation that requires finding a user based on a provided user name, such as DeleteUser, DescribeUser, and so on.

                                                                                                                                                                                                                                                                                                                                                        func (*QuickSightUserNotFoundException) Error

                                                                                                                                                                                                                                                                                                                                                        func (*QuickSightUserNotFoundException) ErrorCode

                                                                                                                                                                                                                                                                                                                                                        func (e *QuickSightUserNotFoundException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                        func (*QuickSightUserNotFoundException) ErrorFault

                                                                                                                                                                                                                                                                                                                                                        func (*QuickSightUserNotFoundException) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                        func (e *QuickSightUserNotFoundException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                        type RdsParameters

                                                                                                                                                                                                                                                                                                                                                        type RdsParameters struct {
                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                        	// Database.
                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                                                                                                                                        	Database *string
                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                        	// Instance ID.
                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                                                                                                                                        	InstanceId *string
                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                          Amazon RDS parameters.

                                                                                                                                                                                                                                                                                                                                                          type RedshiftParameters

                                                                                                                                                                                                                                                                                                                                                          type RedshiftParameters struct {
                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                          	// Database.
                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                          	Database *string
                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                          	// Cluster ID. This field can be blank if the Host and Port are provided.
                                                                                                                                                                                                                                                                                                                                                          	ClusterId *string
                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                          	// Host. This field can be blank if ClusterId is provided.
                                                                                                                                                                                                                                                                                                                                                          	Host *string
                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                          	// Port. This field can be blank if the ClusterId is provided.
                                                                                                                                                                                                                                                                                                                                                          	Port int32
                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                            Amazon Redshift parameters. The ClusterId field can be blank if Host and Port are both set. The Host and Port fields can be blank if the ClusterId field is set.

                                                                                                                                                                                                                                                                                                                                                            type RelationalTable

                                                                                                                                                                                                                                                                                                                                                            type RelationalTable struct {
                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                            	// The Amazon Resource Name (ARN) for the data source.
                                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                                                            	DataSourceArn *string
                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                            	// The column schema of the table.
                                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                                                            	InputColumns []InputColumn
                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                            	// The name of the relational table.
                                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                                                            	Name *string
                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                            	// The catalog associated with a table.
                                                                                                                                                                                                                                                                                                                                                            	Catalog *string
                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                            	// The schema name. This name applies to certain relational database engines.
                                                                                                                                                                                                                                                                                                                                                            	Schema *string
                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                              A physical table type for relational data sources.

                                                                                                                                                                                                                                                                                                                                                              type RenameColumnOperation

                                                                                                                                                                                                                                                                                                                                                              type RenameColumnOperation struct {
                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                              	// The name of the column to be renamed.
                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                                                              	ColumnName *string
                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                              	// The new name for the column.
                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                                                              	NewColumnName *string
                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                A transform operation that renames a column.

                                                                                                                                                                                                                                                                                                                                                                type ResourceExistsException

                                                                                                                                                                                                                                                                                                                                                                type ResourceExistsException struct {
                                                                                                                                                                                                                                                                                                                                                                	Message *string
                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                	ResourceType ExceptionResourceType
                                                                                                                                                                                                                                                                                                                                                                	RequestId    *string
                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                  The resource specified already exists.

                                                                                                                                                                                                                                                                                                                                                                  func (*ResourceExistsException) Error

                                                                                                                                                                                                                                                                                                                                                                  func (e *ResourceExistsException) Error() string

                                                                                                                                                                                                                                                                                                                                                                  func (*ResourceExistsException) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                  func (e *ResourceExistsException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                  func (*ResourceExistsException) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                  func (e *ResourceExistsException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                                                                                                  func (*ResourceExistsException) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                  func (e *ResourceExistsException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                  type ResourceNotFoundException

                                                                                                                                                                                                                                                                                                                                                                  type ResourceNotFoundException struct {
                                                                                                                                                                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                  	ResourceType ExceptionResourceType
                                                                                                                                                                                                                                                                                                                                                                  	RequestId    *string
                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                    One or more resources can't be found.

                                                                                                                                                                                                                                                                                                                                                                    func (*ResourceNotFoundException) Error

                                                                                                                                                                                                                                                                                                                                                                    func (e *ResourceNotFoundException) Error() string

                                                                                                                                                                                                                                                                                                                                                                    func (*ResourceNotFoundException) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                    func (e *ResourceNotFoundException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                    func (*ResourceNotFoundException) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                    func (*ResourceNotFoundException) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                    func (e *ResourceNotFoundException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                    type ResourcePermission

                                                                                                                                                                                                                                                                                                                                                                    type ResourcePermission struct {
                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    	// The IAM action to grant or revoke permissions on.
                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                    	Actions []string
                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    	// The Amazon Resource Name (ARN) of the principal. This can be one of the
                                                                                                                                                                                                                                                                                                                                                                    	// following:
                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                    	// * The ARN of an Amazon QuickSight user or group associated with a
                                                                                                                                                                                                                                                                                                                                                                    	// data source or dataset. (This is common.)
                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                    	// * The ARN of an Amazon QuickSight
                                                                                                                                                                                                                                                                                                                                                                    	// user, group, or namespace associated with an analysis, dashboard, template, or
                                                                                                                                                                                                                                                                                                                                                                    	// theme. (This is common.)
                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                    	// * 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.)
                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                    	Principal *string
                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                      Permission for the resource.

                                                                                                                                                                                                                                                                                                                                                                      type ResourceStatus

                                                                                                                                                                                                                                                                                                                                                                      type ResourceStatus string
                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                      	ResourceStatusCreationInProgress ResourceStatus = "CREATION_IN_PROGRESS"
                                                                                                                                                                                                                                                                                                                                                                      	ResourceStatusCreationSuccessful ResourceStatus = "CREATION_SUCCESSFUL"
                                                                                                                                                                                                                                                                                                                                                                      	ResourceStatusCreationFailed     ResourceStatus = "CREATION_FAILED"
                                                                                                                                                                                                                                                                                                                                                                      	ResourceStatusUpdateInProgress   ResourceStatus = "UPDATE_IN_PROGRESS"
                                                                                                                                                                                                                                                                                                                                                                      	ResourceStatusUpdateSuccessful   ResourceStatus = "UPDATE_SUCCESSFUL"
                                                                                                                                                                                                                                                                                                                                                                      	ResourceStatusUpdateFailed       ResourceStatus = "UPDATE_FAILED"
                                                                                                                                                                                                                                                                                                                                                                      	ResourceStatusDeleted            ResourceStatus = "DELETED"
                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                        Enum values for ResourceStatus

                                                                                                                                                                                                                                                                                                                                                                        func (ResourceStatus) Values

                                                                                                                                                                                                                                                                                                                                                                        func (ResourceStatus) Values() []ResourceStatus

                                                                                                                                                                                                                                                                                                                                                                          Values returns all known values for ResourceStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                          type ResourceUnavailableException

                                                                                                                                                                                                                                                                                                                                                                          type ResourceUnavailableException struct {
                                                                                                                                                                                                                                                                                                                                                                          	Message *string
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	ResourceType ExceptionResourceType
                                                                                                                                                                                                                                                                                                                                                                          	RequestId    *string
                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                            This resource is currently unavailable.

                                                                                                                                                                                                                                                                                                                                                                            func (*ResourceUnavailableException) Error

                                                                                                                                                                                                                                                                                                                                                                            func (*ResourceUnavailableException) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                            func (e *ResourceUnavailableException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                            func (*ResourceUnavailableException) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                            func (*ResourceUnavailableException) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                            func (e *ResourceUnavailableException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                            type RowInfo

                                                                                                                                                                                                                                                                                                                                                                            type RowInfo struct {
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// The number of rows that were not ingested.
                                                                                                                                                                                                                                                                                                                                                                            	RowsDropped int64
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// The number of rows that were ingested.
                                                                                                                                                                                                                                                                                                                                                                            	RowsIngested int64
                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                              Information about rows for a data set SPICE ingestion.

                                                                                                                                                                                                                                                                                                                                                                              type RowLevelPermissionDataSet

                                                                                                                                                                                                                                                                                                                                                                              type RowLevelPermissionDataSet struct {
                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                              	// The Amazon Resource Name (ARN) of the dataset that contains permissions for RLS.
                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                              	Arn *string
                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                              	// The type of permissions to use when interpretting the permissions for RLS.
                                                                                                                                                                                                                                                                                                                                                                              	// DENY_ACCESS is included for backward compatibility only.
                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                              	PermissionPolicy RowLevelPermissionPolicy
                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                              	// The namespace associated with the dataset that contains permissions for RLS.
                                                                                                                                                                                                                                                                                                                                                                              	Namespace *string
                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                Information about a dataset that contains permissions for row-level security (RLS). The permissions dataset maps fields to users or groups. For more information, see Using Row-Level Security (RLS) to Restrict Access to a Dataset (https://docs.aws.amazon.com/quicksight/latest/user/restrict-access-to-a-data-set-using-row-level-security.html) in the Amazon QuickSight User Guide. The option to deny permissions by setting PermissionPolicy to DENY_ACCESS is not supported for new RLS datasets.

                                                                                                                                                                                                                                                                                                                                                                                type RowLevelPermissionPolicy

                                                                                                                                                                                                                                                                                                                                                                                type RowLevelPermissionPolicy string
                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                	RowLevelPermissionPolicyGrantAccess RowLevelPermissionPolicy = "GRANT_ACCESS"
                                                                                                                                                                                                                                                                                                                                                                                	RowLevelPermissionPolicyDenyAccess  RowLevelPermissionPolicy = "DENY_ACCESS"
                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                  Enum values for RowLevelPermissionPolicy

                                                                                                                                                                                                                                                                                                                                                                                  func (RowLevelPermissionPolicy) Values

                                                                                                                                                                                                                                                                                                                                                                                    Values returns all known values for RowLevelPermissionPolicy. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                    type S3Parameters

                                                                                                                                                                                                                                                                                                                                                                                    type S3Parameters struct {
                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                    	// Location of the Amazon S3 manifest file. This is NULL if the manifest file was
                                                                                                                                                                                                                                                                                                                                                                                    	// uploaded in the console.
                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                    	ManifestFileLocation *ManifestFileLocation
                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                      S3 parameters.

                                                                                                                                                                                                                                                                                                                                                                                      type S3Source

                                                                                                                                                                                                                                                                                                                                                                                      type S3Source struct {
                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                      	// The Amazon Resource Name (ARN) for the data source.
                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                      	DataSourceArn *string
                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                      	// A physical table type for as S3 data source.
                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                      	InputColumns []InputColumn
                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                      	// Information about the format for the S3 source file or files.
                                                                                                                                                                                                                                                                                                                                                                                      	UploadSettings *UploadSettings
                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                        A physical table type for as S3 data source.

                                                                                                                                                                                                                                                                                                                                                                                        type ServiceNowParameters

                                                                                                                                                                                                                                                                                                                                                                                        type ServiceNowParameters struct {
                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                        	// URL of the base site.
                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                        	SiteBaseUrl *string
                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                          ServiceNow parameters.

                                                                                                                                                                                                                                                                                                                                                                                          type SessionLifetimeInMinutesInvalidException

                                                                                                                                                                                                                                                                                                                                                                                          type SessionLifetimeInMinutesInvalidException struct {
                                                                                                                                                                                                                                                                                                                                                                                          	Message *string
                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                          	RequestId *string
                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                            The number of minutes specified for the lifetime of a session isn't valid. The session lifetime must be 15-600 minutes.

                                                                                                                                                                                                                                                                                                                                                                                            func (*SessionLifetimeInMinutesInvalidException) Error

                                                                                                                                                                                                                                                                                                                                                                                            func (*SessionLifetimeInMinutesInvalidException) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                            func (*SessionLifetimeInMinutesInvalidException) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                            func (*SessionLifetimeInMinutesInvalidException) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                            type Sheet

                                                                                                                                                                                                                                                                                                                                                                                            type Sheet struct {
                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                            	// The name of a sheet. This name is displayed on the sheet's tab in the QuickSight
                                                                                                                                                                                                                                                                                                                                                                                            	// console.
                                                                                                                                                                                                                                                                                                                                                                                            	Name *string
                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                            	// The unique identifier associated with a sheet.
                                                                                                                                                                                                                                                                                                                                                                                            	SheetId *string
                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                              A sheet, which is an object that contains a set of visuals that are viewed together on one page in the Amazon QuickSight console. Every analysis and dashboard contains at least one sheet. Each sheet contains at least one visualization widget, for example a chart, pivot table, or narrative insight. Sheets can be associated with other components, such as controls, filters, and so on.

                                                                                                                                                                                                                                                                                                                                                                                              type SheetControlsOption

                                                                                                                                                                                                                                                                                                                                                                                              type SheetControlsOption struct {
                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                              	// Visibility state.
                                                                                                                                                                                                                                                                                                                                                                                              	VisibilityState DashboardUIState
                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                Sheet controls option.

                                                                                                                                                                                                                                                                                                                                                                                                type SheetStyle

                                                                                                                                                                                                                                                                                                                                                                                                type SheetStyle struct {
                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                	// The display options for tiles.
                                                                                                                                                                                                                                                                                                                                                                                                	Tile *TileStyle
                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                	// The layout options for tiles.
                                                                                                                                                                                                                                                                                                                                                                                                	TileLayout *TileLayoutStyle
                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                  The theme display options for sheets.

                                                                                                                                                                                                                                                                                                                                                                                                  type SnowflakeParameters

                                                                                                                                                                                                                                                                                                                                                                                                  type SnowflakeParameters struct {
                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                  	// Database.
                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                  	Database *string
                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                  	// Host.
                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                  	Host *string
                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                  	// Warehouse.
                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                  	Warehouse *string
                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                    Snowflake parameters.

                                                                                                                                                                                                                                                                                                                                                                                                    type SparkParameters

                                                                                                                                                                                                                                                                                                                                                                                                    type SparkParameters struct {
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// Host.
                                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                    	Host *string
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// Port.
                                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                    	Port int32
                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                      Spark parameters.

                                                                                                                                                                                                                                                                                                                                                                                                      type SqlServerParameters

                                                                                                                                                                                                                                                                                                                                                                                                      type SqlServerParameters struct {
                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                      	// Database.
                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                      	Database *string
                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                      	// Host.
                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                      	Host *string
                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                      	// Port.
                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                      	Port int32
                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                        SQL Server parameters.

                                                                                                                                                                                                                                                                                                                                                                                                        type SslProperties

                                                                                                                                                                                                                                                                                                                                                                                                        type SslProperties struct {
                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                        	// A Boolean option to control whether SSL should be disabled.
                                                                                                                                                                                                                                                                                                                                                                                                        	DisableSsl bool
                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                          Secure Socket Layer (SSL) properties that apply when QuickSight connects to your underlying data source.

                                                                                                                                                                                                                                                                                                                                                                                                          type StringParameter

                                                                                                                                                                                                                                                                                                                                                                                                          type StringParameter struct {
                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                          	// A display name for a string parameter.
                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                          	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                          	// The values of a string parameter.
                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                          	Values []string
                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                            A string parameter.

                                                                                                                                                                                                                                                                                                                                                                                                            type Tag

                                                                                                                                                                                                                                                                                                                                                                                                            type Tag struct {
                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                            	// Tag key.
                                                                                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                            	Key *string
                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                            	// Tag value.
                                                                                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                            	Value *string
                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                              The key or keys of the key-value pairs for the resource tag or tags assigned to the resource.

                                                                                                                                                                                                                                                                                                                                                                                                              type TagColumnOperation

                                                                                                                                                                                                                                                                                                                                                                                                              type TagColumnOperation struct {
                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                              	// The column that this operation acts on.
                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                              	ColumnName *string
                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                              	// The dataset column tag, currently only used for geospatial type tagging. . This
                                                                                                                                                                                                                                                                                                                                                                                                              	// is not tags for the AWS tagging feature. .
                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                              	Tags []ColumnTag
                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                A transform operation that tags a column with additional information.

                                                                                                                                                                                                                                                                                                                                                                                                                type Template

                                                                                                                                                                                                                                                                                                                                                                                                                type Template struct {
                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                	// The Amazon Resource Name (ARN) of the template.
                                                                                                                                                                                                                                                                                                                                                                                                                	Arn *string
                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                	// Time when this was created.
                                                                                                                                                                                                                                                                                                                                                                                                                	CreatedTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                	// Time when this was last updated.
                                                                                                                                                                                                                                                                                                                                                                                                                	LastUpdatedTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                	// The display name of the template.
                                                                                                                                                                                                                                                                                                                                                                                                                	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                	// The ID for the template. This is unique per AWS Region for each AWS account.
                                                                                                                                                                                                                                                                                                                                                                                                                	TemplateId *string
                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                	// A structure describing the versions of the template.
                                                                                                                                                                                                                                                                                                                                                                                                                	Version *TemplateVersion
                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                  A template object. A template is an entity in QuickSight that encapsulates the metadata required to create an analysis and that you can use to create a dashboard. A template adds a layer of abstraction by using placeholders to replace the dataset associated with an analysis. You can use templates to create dashboards by replacing dataset placeholders with datasets that follow the same schema that was used to create the source analysis and template. You can share templates across AWS accounts by allowing users in other AWS accounts to create a template or a dashboard from an existing template.

                                                                                                                                                                                                                                                                                                                                                                                                                  type TemplateAlias

                                                                                                                                                                                                                                                                                                                                                                                                                  type TemplateAlias struct {
                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                  	// The display name of the template alias.
                                                                                                                                                                                                                                                                                                                                                                                                                  	AliasName *string
                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                  	// The Amazon Resource Name (ARN) of the template alias.
                                                                                                                                                                                                                                                                                                                                                                                                                  	Arn *string
                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                  	// The version number of the template alias.
                                                                                                                                                                                                                                                                                                                                                                                                                  	TemplateVersionNumber *int64
                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                    The template alias.

                                                                                                                                                                                                                                                                                                                                                                                                                    type TemplateError

                                                                                                                                                                                                                                                                                                                                                                                                                    type TemplateError struct {
                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                    	// Description of the error type.
                                                                                                                                                                                                                                                                                                                                                                                                                    	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                    	// Type of error.
                                                                                                                                                                                                                                                                                                                                                                                                                    	Type TemplateErrorType
                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                      List of errors that occurred when the template version creation failed.

                                                                                                                                                                                                                                                                                                                                                                                                                      type TemplateErrorType

                                                                                                                                                                                                                                                                                                                                                                                                                      type TemplateErrorType string
                                                                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                                                                      	TemplateErrorTypeSourceNotFound  TemplateErrorType = "SOURCE_NOT_FOUND"
                                                                                                                                                                                                                                                                                                                                                                                                                      	TemplateErrorTypeDataSetNotFound TemplateErrorType = "DATA_SET_NOT_FOUND"
                                                                                                                                                                                                                                                                                                                                                                                                                      	TemplateErrorTypeInternalFailure TemplateErrorType = "INTERNAL_FAILURE"
                                                                                                                                                                                                                                                                                                                                                                                                                      	TemplateErrorTypeAccessDenied    TemplateErrorType = "ACCESS_DENIED"
                                                                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                                                                        Enum values for TemplateErrorType

                                                                                                                                                                                                                                                                                                                                                                                                                        func (TemplateErrorType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                          Values returns all known values for TemplateErrorType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                          type TemplateSourceAnalysis

                                                                                                                                                                                                                                                                                                                                                                                                                          type TemplateSourceAnalysis struct {
                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                          	// The Amazon Resource Name (ARN) of the resource.
                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                          	Arn *string
                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                          	// A structure containing information about the dataset references used as
                                                                                                                                                                                                                                                                                                                                                                                                                          	// placeholders in the template.
                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                          	DataSetReferences []DataSetReference
                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                            The source analysis of the template.

                                                                                                                                                                                                                                                                                                                                                                                                                            type TemplateSourceEntity

                                                                                                                                                                                                                                                                                                                                                                                                                            type TemplateSourceEntity struct {
                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                            	// The source analysis, if it is based on an analysis.
                                                                                                                                                                                                                                                                                                                                                                                                                            	SourceAnalysis *TemplateSourceAnalysis
                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                            	// The source template, if it is based on an template.
                                                                                                                                                                                                                                                                                                                                                                                                                            	SourceTemplate *TemplateSourceTemplate
                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                              The source entity of the template.

                                                                                                                                                                                                                                                                                                                                                                                                                              type TemplateSourceTemplate

                                                                                                                                                                                                                                                                                                                                                                                                                              type TemplateSourceTemplate struct {
                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                              	// The Amazon Resource Name (ARN) of the resource.
                                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                              	Arn *string
                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                The source template of the template.

                                                                                                                                                                                                                                                                                                                                                                                                                                type TemplateSummary

                                                                                                                                                                                                                                                                                                                                                                                                                                type TemplateSummary struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                	// A summary of a template.
                                                                                                                                                                                                                                                                                                                                                                                                                                	Arn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                	// The last time that this template was created.
                                                                                                                                                                                                                                                                                                                                                                                                                                	CreatedTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                	// The last time that this template was updated.
                                                                                                                                                                                                                                                                                                                                                                                                                                	LastUpdatedTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                	// A structure containing a list of version numbers for the template summary.
                                                                                                                                                                                                                                                                                                                                                                                                                                	LatestVersionNumber *int64
                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                	// A display name for the template.
                                                                                                                                                                                                                                                                                                                                                                                                                                	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                	// The ID of the template. This ID is unique per AWS Region for each AWS account.
                                                                                                                                                                                                                                                                                                                                                                                                                                	TemplateId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                  The template summary.

                                                                                                                                                                                                                                                                                                                                                                                                                                  type TemplateVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                  type TemplateVersion struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The time that this template version was created.
                                                                                                                                                                                                                                                                                                                                                                                                                                  	CreatedTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Schema of the dataset identified by the placeholder. Any dashboard created from
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// this template should be bound to new datasets matching the same schema described
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// through this API operation.
                                                                                                                                                                                                                                                                                                                                                                                                                                  	DataSetConfigurations []DataSetConfiguration
                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The description of the template.
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Description *string
                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Errors associated with this template version.
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Errors []TemplateError
                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// A list of the associated sheets with the unique identifier and name of each
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// sheet.
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Sheets []Sheet
                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The Amazon Resource Name (ARN) of an analysis or template that was used to
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// create this template.
                                                                                                                                                                                                                                                                                                                                                                                                                                  	SourceEntityArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The HTTP status of the request.
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Status ResourceStatus
                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The ARN of the theme associated with this version of the template.
                                                                                                                                                                                                                                                                                                                                                                                                                                  	ThemeArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The version number of the template version.
                                                                                                                                                                                                                                                                                                                                                                                                                                  	VersionNumber *int64
                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                    A version of a template.

                                                                                                                                                                                                                                                                                                                                                                                                                                    type TemplateVersionSummary

                                                                                                                                                                                                                                                                                                                                                                                                                                    type TemplateVersionSummary struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The Amazon Resource Name (ARN) of the template version.
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Arn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The time that this template version was created.
                                                                                                                                                                                                                                                                                                                                                                                                                                    	CreatedTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The description of the template version.
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Description *string
                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The status of the template version.
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Status ResourceStatus
                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The version number of the template version.
                                                                                                                                                                                                                                                                                                                                                                                                                                    	VersionNumber *int64
                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                      The template version.

                                                                                                                                                                                                                                                                                                                                                                                                                                      type TeradataParameters

                                                                                                                                                                                                                                                                                                                                                                                                                                      type TeradataParameters struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Database.
                                                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                      	Database *string
                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Host.
                                                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                      	Host *string
                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Port.
                                                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                      	Port int32
                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                        Teradata parameters.

                                                                                                                                                                                                                                                                                                                                                                                                                                        type TextQualifier

                                                                                                                                                                                                                                                                                                                                                                                                                                        type TextQualifier string
                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                        	TextQualifierDoubleQuote TextQualifier = "DOUBLE_QUOTE"
                                                                                                                                                                                                                                                                                                                                                                                                                                        	TextQualifierSingleQuote TextQualifier = "SINGLE_QUOTE"
                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                          Enum values for TextQualifier

                                                                                                                                                                                                                                                                                                                                                                                                                                          func (TextQualifier) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                          func (TextQualifier) Values() []TextQualifier

                                                                                                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for TextQualifier. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                            type Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                            type Theme struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The Amazon Resource Name (ARN) of the theme.
                                                                                                                                                                                                                                                                                                                                                                                                                                            	Arn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The date and time that the theme was created.
                                                                                                                                                                                                                                                                                                                                                                                                                                            	CreatedTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The date and time that the theme was last updated.
                                                                                                                                                                                                                                                                                                                                                                                                                                            	LastUpdatedTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The name that the user gives to the theme.
                                                                                                                                                                                                                                                                                                                                                                                                                                            	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The identifier that the user gives to the theme.
                                                                                                                                                                                                                                                                                                                                                                                                                                            	ThemeId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The type of theme, based on how it was created. Valid values include: QUICKSIGHT
                                                                                                                                                                                                                                                                                                                                                                                                                                            	// and CUSTOM.
                                                                                                                                                                                                                                                                                                                                                                                                                                            	Type ThemeType
                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                            	// A version of a theme.
                                                                                                                                                                                                                                                                                                                                                                                                                                            	Version *ThemeVersion
                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                              Summary information about a theme.

                                                                                                                                                                                                                                                                                                                                                                                                                                              type ThemeAlias

                                                                                                                                                                                                                                                                                                                                                                                                                                              type ThemeAlias struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The display name of the theme alias.
                                                                                                                                                                                                                                                                                                                                                                                                                                              	AliasName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The Amazon Resource Name (ARN) of the theme alias.
                                                                                                                                                                                                                                                                                                                                                                                                                                              	Arn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The version number of the theme alias.
                                                                                                                                                                                                                                                                                                                                                                                                                                              	ThemeVersionNumber *int64
                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                An alias for a theme.

                                                                                                                                                                                                                                                                                                                                                                                                                                                type ThemeConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                                                                type ThemeConfiguration struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Color properties that apply to chart data colors.
                                                                                                                                                                                                                                                                                                                                                                                                                                                	DataColorPalette *DataColorPalette
                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Display options related to sheets.
                                                                                                                                                                                                                                                                                                                                                                                                                                                	Sheet *SheetStyle
                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Color properties that apply to the UI and to charts, excluding the colors that
                                                                                                                                                                                                                                                                                                                                                                                                                                                	// apply to data.
                                                                                                                                                                                                                                                                                                                                                                                                                                                	UIColorPalette *UIColorPalette
                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                  The theme configuration. This configuration contains all of the display properties for a theme.

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ThemeError

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ThemeError struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The error message.
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The type of error.
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Type ThemeErrorType
                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ThemeErrorType

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ThemeErrorType string
                                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ThemeErrorTypeInternalFailure ThemeErrorType = "INTERNAL_FAILURE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enum values for ThemeErrorType

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (ThemeErrorType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (ThemeErrorType) Values() []ThemeErrorType

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for ThemeErrorType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ThemeSummary

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ThemeSummary struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The Amazon Resource Name (ARN) of the resource.
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Arn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The date and time that this theme was created.
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	CreatedTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The last date and time that this theme was updated.
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	LastUpdatedTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The latest version number for the theme.
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	LatestVersionNumber *int64
                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// the display name for the theme.
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The ID of the theme. This ID is unique per AWS Region for each AWS account.
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ThemeId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                          The theme summary.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ThemeType

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ThemeType string
                                                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ThemeTypeQuicksight ThemeType = "QUICKSIGHT"
                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ThemeTypeCustom     ThemeType = "CUSTOM"
                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ThemeTypeAll        ThemeType = "ALL"
                                                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enum values for ThemeType

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (ThemeType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (ThemeType) Values() []ThemeType

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Values returns all known values for ThemeType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ThemeVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ThemeVersion struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The Amazon Resource Name (ARN) of the resource.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Arn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The Amazon QuickSight-defined ID of the theme that a custom theme inherits from.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// All themes initially inherit from a default QuickSight theme.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	BaseThemeId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The theme configuration, which contains all the theme display properties.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Configuration *ThemeConfiguration
                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The date and time that this theme version was created.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	CreatedTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The description of the theme.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Description *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Errors associated with the theme.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Errors []ThemeError
                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The status of the theme version.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Status ResourceStatus
                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The version number of the theme.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	VersionNumber *int64
                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                A version of a theme.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ThemeVersionSummary

                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ThemeVersionSummary struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The Amazon Resource Name (ARN) of the theme version.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Arn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The date and time that this theme version was created.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CreatedTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The description of the theme version.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Description *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The status of the theme version.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Status ResourceStatus
                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The version number of the theme version.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	VersionNumber *int64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The theme version.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ThrottlingException

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ThrottlingException struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	RequestId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Access is throttled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*ThrottlingException) Error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (e *ThrottlingException) Error() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*ThrottlingException) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (e *ThrottlingException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*ThrottlingException) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (e *ThrottlingException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*ThrottlingException) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (e *ThrottlingException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TileLayoutStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TileLayoutStyle struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The gutter settings that apply between tiles.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Gutter *GutterStyle
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The margin settings that apply around the outside edge of sheets.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Margin *MarginStyle
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The display options for the layout of tiles on a sheet.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TileStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TileStyle struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The border around a tile.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Border *BorderStyle
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Display options related to tiles on a sheet.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TransformOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TransformOperation interface {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// contains filtered or unexported methods
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A data transformation on a logical table. This is a variant type structure. For this structure to be valid, only one of the attributes can be non-null.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The following types satisfy this interface:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TransformOperationMemberProjectOperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TransformOperationMemberFilterOperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TransformOperationMemberCreateColumnsOperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TransformOperationMemberRenameColumnOperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TransformOperationMemberCastColumnTypeOperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TransformOperationMemberTagColumnOperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Example (OutputUsage)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Output:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TransformOperationMemberCastColumnTypeOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TransformOperationMemberCastColumnTypeOperation struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Value CastColumnTypeOperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A transform operation that casts a column to a different type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TransformOperationMemberCreateColumnsOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TransformOperationMemberCreateColumnsOperation struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Value CreateColumnsOperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              An operation that creates calculated columns. Columns created in one such operation form a lexical closure.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TransformOperationMemberFilterOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TransformOperationMemberFilterOperation struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Value FilterOperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                An operation that filters rows based on some condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TransformOperationMemberProjectOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TransformOperationMemberProjectOperation struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Value ProjectOperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An operation that projects columns. Operations that come after a projection can only refer to projected columns.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TransformOperationMemberRenameColumnOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TransformOperationMemberRenameColumnOperation struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Value RenameColumnOperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operation that renames a column.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TransformOperationMemberTagColumnOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TransformOperationMemberTagColumnOperation struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Value TagColumnOperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An operation that tags a column with additional information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TwitterParameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TwitterParameters struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Maximum number of rows to query Twitter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	MaxRows int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Twitter query string.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Query *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Twitter parameters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type UIColorPalette

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type UIColorPalette struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// This color is that applies to selected states and buttons.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Accent *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The foreground color that applies to any text or other elements that appear over
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// the accent color.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	AccentForeground *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The color that applies to error messages.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Danger *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The foreground color that applies to any text or other elements that appear over
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// the error color.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	DangerForeground *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The color that applies to the names of fields that are identified as dimensions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Dimension *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The foreground color that applies to any text or other elements that appear over
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// the dimension color.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	DimensionForeground *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The color that applies to the names of fields that are identified as measures.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Measure *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The foreground color that applies to any text or other elements that appear over
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// the measure color.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	MeasureForeground *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The background color that applies to visuals and other high emphasis UI.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	PrimaryBackground *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// 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.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	PrimaryForeground *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The background color that applies to the sheet background and sheet controls.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SecondaryBackground *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The foreground color that applies to any sheet title, sheet control text, or UI
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// that appears over the secondary background.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SecondaryForeground *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The color that applies to success messages, for example the check mark for a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// successful download.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Success *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The foreground color that applies to any text or other elements that appear over
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// the success color.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SuccessForeground *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// This color that applies to warning and informational messages.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Warning *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The foreground color that applies to any text or other elements that appear over
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// the warning color.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	WarningForeground *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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 #, for example #37BFF5. For more information, see Using Themes in Amazon QuickSight (https://docs.aws.amazon.com/quicksight/latest/user/themes-in-quicksight.html) in the Amazon QuickSight User Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type UnknownUnionMember

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type UnknownUnionMember struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Tag   string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Value []byte
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            UnknownUnionMember is returned when a union member is returned over the wire, but has an unknown tag.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type UnsupportedPricingPlanException

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type UnsupportedPricingPlanException struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	RequestId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This error indicates that you are calling an embedding operation in Amazon QuickSight without the required pricing plan on your AWS account. Before you can use embedding for anonymous users, a QuickSight administrator needs to add capacity pricing to QuickSight. You can do this on the Manage QuickSight page. After capacity pricing is added, you can use the GetDashboardEmbedUrl API operation with the --identity-type ANONYMOUS option.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*UnsupportedPricingPlanException) Error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*UnsupportedPricingPlanException) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (e *UnsupportedPricingPlanException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*UnsupportedPricingPlanException) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*UnsupportedPricingPlanException) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (e *UnsupportedPricingPlanException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type UnsupportedUserEditionException

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type UnsupportedUserEditionException struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	RequestId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This error indicates that you are calling an operation on an Amazon QuickSight subscription where the edition doesn't include support for that operation. Amazon QuickSight currently has Standard Edition and Enterprise Edition. Not every operation and capability is available in every edition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*UnsupportedUserEditionException) Error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*UnsupportedUserEditionException) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (e *UnsupportedUserEditionException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*UnsupportedUserEditionException) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*UnsupportedUserEditionException) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (e *UnsupportedUserEditionException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type UploadSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type UploadSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Whether the file has a header row, or the files each have a header row.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ContainsHeader bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The delimiter between values in the file.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Delimiter *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// File format.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Format FileFormat
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// A row number to start reading data from.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	StartFromRow int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Text qualifier.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	TextQualifier TextQualifier
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Information about the format for a source file or files.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type User

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type User struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The active status of user. When you create an Amazon QuickSight user that’s not
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// an IAM user or an Active Directory user, that user is inactive until they sign
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// in and provide a password.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Active bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The Amazon Resource Name (ARN) for the user.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Arn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The custom permissions profile associated with this user.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	CustomPermissionsName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The user's email address.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Email *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The type of identity authentication used by the user.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	IdentityType IdentityType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The principal ID of the user.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	PrincipalId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The Amazon QuickSight role for the user. The user role can be one of the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// following:.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// * READER: A user who has read-only access to dashboards.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// * AUTHOR:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// A user who can create data sources, datasets, analyses, and dashboards.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// ADMIN: A user who is an author, who can also manage Amazon QuickSight
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// settings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// * RESTRICTED_READER: This role isn't currently available for use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// RESTRICTED_AUTHOR: This role isn't currently available for use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Role UserRole
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The user's user name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	UserName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A registered user of Amazon QuickSight.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type UserRole

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type UserRole string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	UserRoleAdmin            UserRole = "ADMIN"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	UserRoleAuthor           UserRole = "AUTHOR"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	UserRoleReader           UserRole = "READER"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	UserRoleRestrictedAuthor UserRole = "RESTRICTED_AUTHOR"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	UserRoleRestrictedReader UserRole = "RESTRICTED_READER"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enum values for UserRole

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (UserRole) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (UserRole) Values() []UserRole

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for UserRole. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type VpcConnectionProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type VpcConnectionProperties struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The Amazon Resource Name (ARN) for the VPC connection.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	VpcConnectionArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          VPC connection properties.